Bump version to 2.47.2 (#777)

Author: vagabondHustler

.github/configs/version_control.json

@@ -1,5 +1,5 @@
 {
-  "current_version": "2.47.1",
-  "previous_version": "2.47.1dev0",
-  "last_stable_release": "2.47.1"
+  "current_version": "2.47.2",
+  "previous_version": "2.47.2dev4",
+  "last_stable_release": "2.47.2"
 }

.gitignore

@@ -173,3 +173,5 @@ artifacts
 artifacts/*
 .GITHUB_OUTPUT
 .GITHUB_STEP_SUMMARY
+cspell.json
+cspell.config.yaml

pyproject.toml

@@ -70,15 +70,15 @@
 [project.optional-dependencies]
     build = [
         "build==1.2.2.post1",
-        "cx_Freeze==8.0.0",
+        "cx_Freeze==8.1.0",
         "twine==6.1.0",
         "psutil==7.0.0",
     ]
     lint = ["black==25.1.0", "isort==6.0.1"]
     tests = [
-        "pytest-cov==6.0.0",
+        "pytest-cov==6.1.1",
         "pytest==8.3.5",
-        "tox==4.24.2",
+        "tox==4.25.0",
         "python-dotenv==1.1.0",
     ]
     tools = ["pyperclip==1.9.0"]

src/subsearch/__init__.py

@@ -24,7 +24,6 @@ def start_app(self) -> None:
         )
         self.subsearch_core.download_files()
         self.subsearch_core.download_manager()
-        self.subsearch_core.extract_files()
         self.subsearch_core.subtitle_post_processing()
         self.subsearch_core.clean_up()
 

src/subsearch/core.py

@@ -18,7 +18,6 @@ def __init__(self, pref_counter: float) -> None:
         log.brackets("Initializing")
 
         self.api_calls_made: dict[str, int] = {}
-        self.downloaded_subtitles = 0
         self.ran_download_tab = False
         self.accepted_subtitles: list[Subtitle] = []
         self.rejected_subtitles: list[Subtitle] = []
@@ -28,6 +27,11 @@ def __init__(self, pref_counter: float) -> None:
         self.file_exist = VIDEO_FILE.file_exist
         self.autoload_src = ""
 
+        self.downloaded_subtitles: int = 0
+        self.downloaded_subtitle_archives: int = 0
+        self.extracted_subtitle_archives: int = 0
+        self.user_downloaded_files = False
+
         log.stdout("Verifing files and paths", level="debug")
         self.setup_file_system()
         self.language_data = io_toml.load_toml_data(FILE_PATHS.language_data)
@@ -57,11 +61,8 @@ def __init__(self, pref_counter: float) -> None:
                 provider_urls=self.provider_urls,
                 language_data=self.language_data,
             )
-        self.refresh_call_conditions_attrs()
-        log.task_completed()
-
-    def refresh_call_conditions_attrs(self) -> None:
         self.call_conditions = CallConditions(self)
+        log.task_completed()
 
     def update_imdb_id(self) -> None:
         timeout = self.app_config.request_connect_timeout, self.app_config.request_read_timeout
@@ -93,6 +94,19 @@ def all_providers_disabled(self) -> bool:
             return True
         return False
 
+    def prevent_conflicting_config_settings(self) -> None:
+        # TODO
+        # make settings exclusive in GUI
+        if self.app_config.open_on_no_matches and self.app_config.always_open:
+            self.app_config.open_on_no_matches = False
+            io_toml.update_toml_key(FILE_PATHS.config, "download_manager.open_on_no_matches", False)
+        if (
+            self.app_config.subtitle_post_processing["move_best"]
+            and self.app_config.subtitle_post_processing["move_all"]
+        ):
+            self.app_config.subtitle_post_processing["move_best"] = False
+            io_toml.update_toml_key(FILE_PATHS.config, "subtitle_post_processing.move_best", False)
+
 
 class SubsearchCore(Initializer):
     def __init__(self, pref_counter: float) -> None:
@@ -102,14 +116,18 @@ def __init__(self, pref_counter: float) -> None:
             log.brackets("GUI")
             screen_manager.open_screen("search_options")
             log.stdout("Exiting GUI", level="debug")
+            self.prevent_conflicting_config_settings()
             return None
 
         if " " in VIDEO_FILE.filename:
             log.stdout(f"{VIDEO_FILE.filename} contains spaces, result may vary", level="warning")
 
         if not self.all_providers_disabled():
+            self.prevent_conflicting_config_settings()
             log.brackets("Search started")
 
+
+
     @decorators.call_func
     def init_search(self, *providers: Callable[..., None]) -> None:
         thread_handle._create_threads(*providers)
@@ -146,7 +164,6 @@ def download_files(self) -> None:
             else:
                 s = self.accepted_subtitles.pop(index_position)
                 self.rejected_subtitles.append(s)
-        self.refresh_call_conditions_attrs()
         log.task_completed()
 
     def _handle_subsource_subtitle(self, index_position: int, subtitle: Subtitle) -> None:
@@ -166,28 +183,33 @@ def download_manager(self) -> None:
         subtitles = self.rejected_subtitles + self.accepted_subtitles
         screen_manager.open_screen("download_manager", subtitles=subtitles)
         self.manually_accepted_subtitles = download_manager.DownloadManager.downloaded_subtitle
+        self.downloaded_subtitles += len(self.manually_accepted_subtitles)
         log.task_completed()
 
     @decorators.call_func
-    def extract_files(self) -> None:
-        log.brackets("Extracting downloads")
-        io_file_system.extract_files_in_dir(VIDEO_FILE.tmp_dir, VIDEO_FILE.subs_dir)
-        log.task_completed()
-
-    @decorators.call_func
-    def subtitle_post_processing(self):
+    def subtitle_post_processing(self) -> None:
         target = self.app_config.subtitle_post_processing["target_path"]
         resolution = self.app_config.subtitle_post_processing["path_resolution"]
         target_path = io_file_system.create_path_from_string(target, resolution)
+        self.downloaded_subtitle_archives = io_file_system.count_files_in_directory(VIDEO_FILE.tmp_dir)
+        self.extract_files()
+        self.extracted_subtitle_archives = io_file_system.count_files_in_directory(VIDEO_FILE.subs_dir, [".srt"])
         self.subtitle_rename()
         self.subtitle_move_best(target_path)
         self.subtitle_move_all(target_path)
 
+    @decorators.call_func
+    def extract_files(self) -> None:
+        log.brackets("Extracting downloads")
+        io_file_system.extract_files_in_dir(VIDEO_FILE.tmp_dir, VIDEO_FILE.subs_dir)
+        log.task_completed()
+
     @decorators.call_func
     def subtitle_rename(self) -> None:
         log.brackets("Renaming best match")
         new_name = io_file_system.autoload_rename(VIDEO_FILE.filename, ".srt")
         self.autoload_src = new_name
+        
         log.task_completed()
 
     @decorators.call_func
@@ -206,14 +228,13 @@ def subtitle_move_all(self, target: Path) -> None:
     def summary_notification(self, elapsed) -> None:
         log.brackets("Summary toast")
         elapsed_summary = f"Finished in {elapsed} seconds"
-        tot_num_of_subtitles = len(self.accepted_subtitles) + len(self.rejected_subtitles)
-        all_downloaded = self.downloaded_subtitles + len(self.manually_accepted_subtitles)
-        matches_downloaded = f"Downloaded: {all_downloaded}/{tot_num_of_subtitles}"
-        if all_downloaded > 0:
+        number_of_results = len(self.accepted_subtitles) + len(self.rejected_subtitles)
+        matches_downloaded = f"Downloaded: {self.downloaded_subtitles}/{number_of_results}"
+        if self.downloaded_subtitles >= 1:
             msg = "Search Succeeded", f"{matches_downloaded}\n{elapsed_summary}"
             log.stdout(matches_downloaded, hex_color="#a6e3a1")
             self.system_tray.display_toast(*msg)
-        elif all_downloaded == 0:
+        elif self.downloaded_subtitles == 0:
             msg = "Search Failed", f"{matches_downloaded}\n{elapsed_summary}"
             log.stdout(matches_downloaded, hex_color="#f38ba8")
             self.system_tray.display_toast(*msg)
@@ -248,14 +269,19 @@ def core_on_exit(self) -> None:
 class CallConditions:
 
     def __init__(self, cls: SubsearchCore) -> None:
-        self.app_config = cls.app_config
-        self.file_exist = cls.file_exist
-        self.release_data = cls.release_data
-        self.provider_urls = cls.provider_urls
-        self.language_data = cls.language_data
-        self.accepted_subtitles = cls.accepted_subtitles
-        self.rejected_subtitles = cls.rejected_subtitles
-        self.downloaded_subtitles = cls.downloaded_subtitles
+        self.cls = cls
+        self.refresh_parent_attrs()
+
+    def refresh_parent_attrs(self) -> None:
+        self.app_config = self.cls.app_config
+        self.file_exist = self.cls.file_exist
+        self.release_data = self.cls.release_data
+        self.provider_urls = self.cls.provider_urls
+        self.language_data = self.cls.language_data
+        self.accepted_subtitles = self.cls.accepted_subtitles
+        self.rejected_subtitles = self.cls.rejected_subtitles
+        self.downloaded_subtitle_archives = self.cls.downloaded_subtitle_archives
+        self.extracted_subtitle_archives = self.cls.extracted_subtitle_archives
 
     def check_language_compatibility(self, provider: str) -> bool:
         language = self.app_config.current_language
@@ -270,6 +296,7 @@ def all_conditions_true(self, conditions: list[bool]) -> bool:
 
     def call_func(self, *args, **kwargs) -> bool:
         func_name = kwargs["func_name"]
+        self.refresh_parent_attrs()
         conditions: dict[str, list[bool]] = {
             "init_search": [self.file_exist],
             "opensubtitles": [
@@ -292,8 +319,7 @@ def call_func(self, *args, **kwargs) -> bool:
                 self.app_config.providers["subsource_site"],
             ],
             "download_files": [
-                len(self.accepted_subtitles) >= 1
-                and self.app_config.automatic_downloads
+                (len(self.accepted_subtitles) >= 1 and self.app_config.automatic_downloads)
                 or (
                     len(self.accepted_subtitles) >= 1
                     and not self.app_config.automatic_downloads
@@ -314,27 +340,24 @@ def call_func(self, *args, **kwargs) -> bool:
                     )
                 ),
             ],
-            "extract_files": [
-                len(self.accepted_subtitles) >= 1,
-            ],
             "subtitle_post_processing": [
                 self.file_exist,
             ],
+            "extract_files": [
+                self.downloaded_subtitle_archives >= 1,
+            ],
             "subtitle_rename": [
-                self.file_exist,
+                self.extracted_subtitle_archives >= 1,
                 self.app_config.subtitle_post_processing["rename"],
-                self.downloaded_subtitles >= 1,
             ],
             "subtitle_move_best": [
-                self.file_exist,
+                self.extracted_subtitle_archives >= 1,
                 self.app_config.subtitle_post_processing["move_best"],
-                self.downloaded_subtitles >= 1,
                 not self.app_config.subtitle_post_processing["move_all"],
             ],
             "subtitle_move_all": [
-                self.file_exist,
+                self.extracted_subtitle_archives >= 1,
                 self.app_config.subtitle_post_processing["move_all"],
-                self.downloaded_subtitles > 1,
             ],
             "summary_notification": [
                 self.file_exist,

src/subsearch/data/version.py

@@ -1 +1 @@
-__version__ = "2.47.1"
+__version__ = "2.47.2"

src/subsearch/globals/_logging.py

@@ -3,7 +3,7 @@
 import threading
 from datetime import datetime
 from pathlib import Path
-from typing import Callable, Optional
+from typing import Any, Callable, Optional
 
 import picologging as logging
 
@@ -12,8 +12,8 @@
 from subsearch.globals.dataclasses import GenericDataClass
 
 
-def capture_call_info(func) -> Callable[..., None]:
-    def wrapper(*args, **kwargs):
+def capture_call_info(func: Callable[..., Any]) -> Callable[..., Any]:
+    def wrapper(*args, **kwargs) -> Any:
         frame = inspect.currentframe().f_back  # type: ignore
         current_time = datetime.now().time()
         call_time = current_time.strftime("%H:%M:%S.%f")[:-3]

src/subsearch/gui/common_utils.py

@@ -9,7 +9,7 @@ class WindowPosition(tk.Frame):
     def __init__(self, parent) -> None:
         tk.Frame.__init__(self, parent)
 
-    def set(self, **kwargs):
+    def set(self, **kwargs) -> str:
         w = kwargs.get("w", cfg.size.width)
         h = kwargs.get("h", cfg.size.height)
         ws_value_offset = kwargs.get("ws_value_offset", 0)
@@ -23,7 +23,7 @@ def set(self, **kwargs):
 
 
 class ToolTip(tk.Toplevel):
-    def __init__(self, parent, widget, *text_strings, **kwargs):
+    def __init__(self, parent, widget, *text_strings, **kwargs) -> None:
         self.parent = parent
         self.widget = widget
         self.text = text_strings
@@ -68,7 +68,7 @@ def hide(self) -> None:
         self.destroy()
 
 
-def configure_root(root):
+def configure_root(root) -> None:
     if io_toml.load_toml_value(FILE_PATHS.config, "gui.context_menu"):
         io_winreg.add_context_menu()
     root.configure(background=cfg.color.default_bg)

src/subsearch/gui/screen_manager.py

@@ -75,7 +75,7 @@ def release_menu_btn(self, event) -> None:
         self.activate_screen()
         self.deactivate_screen()
 
-    def get_btn(self, btns: dict, event_: Any, equals=True):
+    def get_btn(self, btns: dict, event_: Any, equals=True) -> tuple | None:
         for btn_key, btn_widget in btns.items():
             if event_.widget == btn_widget and equals:
                 return btn_key, btn_widget
@@ -145,6 +145,6 @@ def open_screen(tab_name: str, **kwargs) -> None:
     root.mainloop()
 
 
-def close_mainloop(event):
+def close_mainloop(event) -> None:
     if event.keysym == "Escape":
         root.destroy()

src/subsearch/gui/screens/search_options.py

@@ -204,14 +204,14 @@ def __init__(self, parent) -> None:
         apply_input.bind("<Leave>", self.leave_btn_apply_input)
         self.entry_path.bind("<Enter>", self.enter_entry_path)
 
-    def enter_entry_path(self, event):
+    def enter_entry_path(self, event) -> None:
         widget_ = event.widget
         path = widget_.get()
         old_path = path.replace("Invalid path: ", "")
         widget_.delete(0, tk.END)
         widget_.insert(tk.END, old_path)
 
-    def enter_btn_apply_input(self, event):
+    def enter_btn_apply_input(self, event) -> None:
         widget_ = event.widget
         path = self.verify_path()
         if self.entry_path.instate(["invalid"]):
@@ -224,7 +224,7 @@ def enter_btn_resolution(self, event) -> None:
         widget_ = event.widget
         widget_.bind("<ButtonPress-1>", self.toogle_path_resolution)
 
-    def leave_btn_apply_input(self, event):
+    def leave_btn_apply_input(self, event) -> None:
         widget_ = event.widget
         path = self.verify_path()
         if self.entry_path.instate(["invalid"]):
@@ -237,7 +237,7 @@ def leave_btn_resolution(self, event) -> None:
         widget_ = event.widget
         widget_.unbind("<ButtonPress-1>")
 
-    def update_config(self, event):
+    def update_config(self, event) -> None:
         target_path = self.entry_path.get()
         path_resolution = self.path_resolution.get().lower()
         io_toml.update_toml_key(FILE_PATHS.config, "subtitle_post_processing.target_path", target_path)
@@ -252,7 +252,7 @@ def verify_path(self) -> str:
             self.entry_path.state(["!invalid"])
         return target_path
 
-    def on_invalid_state(self, path):
+    def on_invalid_state(self, path) -> None:
         invalid_path = path.replace("Invalid path: ", "")
         self.entry_path.delete(0, tk.END)
         self.entry_path.insert(tk.END, f"Invalid path: {invalid_path}")
@@ -310,7 +310,7 @@ def __init__(self, parent) -> None:
         self.slider.bind("<Enter>", self.enter_button)
         self.slider.bind("<Leave>", self.leave_button)
 
-    def get_value(self):
+    def get_value(self) -> int:
         return self.current_value.get()
 
     def set_value(self, event) -> None: