Merge branch 'refs/heads/development' into python_and_deps_upgrade

Author: morpheus65535

bazarr/app/check_update.py

@@ -221,6 +221,7 @@ def update_cleaner(zipfile, bazarr_dir, config_dir):
     dir_to_ignore = [f'^.{separator}',
                      f'^bin{separator}',
                      f'^venv{separator}',
+                     f'^.venv{separator}',
                      f'^WinPython{separator}',
                      f'{separator}__pycache__{separator}$']
     if os.path.abspath(bazarr_dir).lower() == os.path.abspath(config_dir).lower():

bazarr/app/get_providers.py

@@ -94,6 +94,7 @@ def provider_throttle_map():
             TooManyRequests: (datetime.timedelta(minutes=10), "10 minutes"),
         },
         "titulky": {
+            TooManyRequests: (datetime.timedelta(minutes=1), "1 minute"),
             DownloadLimitExceeded: (
                 titulky_limit_reset_timedelta(),
                 f"{titulky_limit_reset_timedelta().seconds // 3600 + 1} hours")

bazarr/app/jobs_queue.py

@@ -504,16 +504,19 @@ def consume_jobs_pending_queue(self):
         """
         while True:
             try:
-                with self._queue_lock:
-                    can_run_job = (len(self.jobs_running_queue) < settings.general.concurrent_jobs
-                                   and len(self.jobs_pending_queue) > 0)
-
-                if can_run_job:
-                    job_thread = Thread(target=self._run_job)
-                    job_thread.daemon = True
-                    job_thread.start()
+                if self.jobs_pending_queue:
+                    with self._queue_lock:
+                        can_run_job = (len(self.jobs_running_queue) < settings.general.concurrent_jobs
+                                       and len(self.jobs_pending_queue) > 0)
+
+                    if can_run_job:
+                        job_thread = Thread(target=self._run_job)
+                        job_thread.daemon = True
+                        job_thread.start()
+                    else:
+                        sleep(0.5)
                 else:
-                    sleep(0.1)
+                    sleep(0.5)
             except (KeyboardInterrupt, SystemExit):
                 break
 

bazarr/subtitles/processing.py

@@ -98,8 +98,7 @@ def process_subtitle(subtitle, media_type, audio_language, path, max_score, is_u
                            percent_score=percent_score,
                            sonarr_series_id=episode_metadata.sonarrSeriesId,
                            sonarr_episode_id=episode_metadata.sonarrEpisodeId,
-                           job_id=job_id,
-                           job_sub_function=True)
+                           job_id=job_id)
     else:
         movie_metadata = database.execute(
             select(TableMovies.radarrId, TableMovies.imdbId)
@@ -118,8 +117,7 @@ def process_subtitle(subtitle, media_type, audio_language, path, max_score, is_u
                            srt_lang=downloaded_language_code2,
                            percent_score=percent_score,
                            radarr_id=movie_metadata.radarrId,
-                           job_id=job_id,
-                           job_sub_function=True)
+                           job_id=job_id)
 
     if use_postprocessing is True:
         command = pp_replace(postprocessing_cmd, path, downloaded_path, downloaded_language, downloaded_language_code2,

bazarr/subtitles/sync.py

@@ -23,20 +23,16 @@ def sync_subtitles(video_path,
                    gss=settings.subsync.gss,
                    no_fix_framerate=settings.subsync.no_fix_framerate,
                    reference=None,
-                   force_sync=False,
-                   job_sub_function=False):
+                   force_sync=False):
     if not settings.subsync.use_subsync and not force_sync:
         logging.debug('BAZARR automatic syncing is disabled in settings. Skipping sync routine.')
         return False
 
     if not job_id:
-        jobs_queue.add_job_from_function("Subtitles synchronization", is_progress=True)
+        jobs_queue.add_job_from_function(f"Syncing {srt_path}", is_progress=False)
         return False
 
-    if job_sub_function:
-        jobs_queue.update_job_progress_status(job_id=job_id, is_progress=True)
-
-    jobs_queue.update_job_progress(job_id=job_id, progress_message=f"Syncing {srt_path}")
+    jobs_queue.update_job_name(job_id=job_id, new_job_name=f"Syncing {srt_path}")
 
     if forced:
         logging.debug('BAZARR cannot sync forced subtitles. Skipping sync routine.')
@@ -65,10 +61,6 @@ def sync_subtitles(video_path,
                 'sonarr_series_id': sonarr_series_id,
                 'sonarr_episode_id': sonarr_episode_id,
                 'radarr_id': radarr_id,
-                'progress_callback': lambda x: jobs_queue.update_job_progress(job_id=x['job_id'],
-                                                                              progress_value=x['value'],
-                                                                              progress_max=x['count'],
-                                                                              progress_message=f"Syncing {srt_path}"),
                 'job_id': job_id,
                 'force_sync': force_sync,
             }
@@ -81,13 +73,11 @@ def sync_subtitles(video_path,
             else:
                 return True
             finally:
-                jobs_queue.update_job_progress(job_id=job_id, progress_value="max",
-                                               progress_message=f"Synced {srt_path}")
+                jobs_queue.update_job_name(job_id=job_id, new_job_name=f"Synced {srt_path}")
                 del subsync
                 gc.collect()
         else:
             logging.debug(f"BAZARR subsync skipped because subtitles score isn't below this "
                           f"threshold value: {subsync_threshold}%")
 
-    jobs_queue.update_job_progress(job_id=job_id, progress_value="max", progress_message=f"Synced {srt_path}")
     return False

bazarr/subtitles/tools/subsyncer.py

@@ -2,11 +2,8 @@
 
 import logging
 import os
-import threading
-import time
 
 from ffsubsync.ffsubsync import run, make_parser
-from tqdm import tqdm
 
 from utilities.binaries import get_binary
 from radarr.history import history_log_movie
@@ -34,77 +31,16 @@ def __init__(self):
         self.log_dir_path = os.path.join(args.config_dir, 'log')
         self.progress_callback = None
         self.sync_result = None
-        self.sync_exception = None
-        self._tqdm_instance = None
         self.job_id = None
 
-    @staticmethod
-    def _capture_tqdm_instance():
-        """Capture the tqdm instance from ffsubsync's VideoSpeechTransformer."""
-        try:
-            # Get all active tqdm instances
-            if hasattr(tqdm, '_instances'):
-                instances = list(tqdm._instances)
-                if instances:
-                    # Return the most recent instance
-                    return instances[-1]
-        except Exception as e:
-            logging.debug(f'BAZARR unable to capture tqdm instance: {e}')
-        return None
-
-    def _monitor_tqdm_progress(self, job_id):
-        """Monitor tqdm progress in a loop."""
-        last_n = 0
-        last_total = 0
-        
-        while self.sync_result is None and self.sync_exception is None:
-            try:
-                time.sleep(1)  # Check every 1s
-                
-                # Try to capture tqdm instance if we don't have it yet
-                if self._tqdm_instance is None:
-                    self._tqdm_instance = self._capture_tqdm_instance()
-                
-                if self._tqdm_instance is not None:
-                    # Access tqdm's internal state
-                    current_n = getattr(self._tqdm_instance, 'n', 0)
-                    total = getattr(self._tqdm_instance, 'total', 0)
-                    
-                    # Only send update if values changed
-                    if current_n != last_n or total != last_total:
-                        last_n = current_n
-                        last_total = total
-                        
-                        if self.progress_callback and total:
-                            # Convert to integer percentages for a cleaner display
-                            value = int(current_n)
-                            count = int(total)
-                            
-                            self.progress_callback({
-                                'job_id': job_id,
-                                'value': value,
-                                'count': count,
-                            })
-            except Exception as e:
-                logging.debug(f'BAZARR error monitoring tqdm progress: {e}')
-                time.sleep(1)  # Wait longer on error
-
-    def _run_sync_in_thread(self):
-        """Run the sync operation in a separate thread."""
-        try:
-            self.sync_result = run(self.args)
-        except Exception as e:
-            self.sync_exception = e
-
     def sync(self, video_path, srt_path, srt_lang, hi, forced,
              max_offset_seconds, no_fix_framerate, gss, reference=None, sonarr_series_id=None, sonarr_episode_id=None,
              radarr_id=None, progress_callback=None, job_id=None, force_sync=False):
         self.reference = video_path
         self.srtin = srt_path
         self.progress_callback = progress_callback
         self.sync_result = None
-        self.sync_exception = None
-        self._tqdm_instance = None
+
         if self.srtin.casefold().endswith('.ass'):
             # try to preserve the original subtitle style
             # ffmpeg will be able to handle this automatically as long as it has the libass filter
@@ -164,31 +100,7 @@ def sync(self, video_path, srt_path, srt_lang, hi, forced,
                 os.remove(self.srtout)
                 logging.debug('BAZARR deleted the previous subtitles synchronization attempt file.')
 
-            # Start sync in a separate thread
-            sync_thread = threading.Thread(target=self._run_sync_in_thread, daemon=False)
-            sync_thread.start()
-
-            # Start progress monitoring if callback provided
-            if progress_callback:
-                # Give the sync thread a moment to start and create tqdm instance
-                time.sleep(0.5)
-                monitor_thread = threading.Thread(
-                    target=self._monitor_tqdm_progress,
-                    args=(job_id,),
-                    daemon=False
-                )
-                monitor_thread.start()
-
-                # Wait for both threads to complete
-                sync_thread.join()
-                monitor_thread.join()
-            else:
-                # Just wait for sync to complete
-                sync_thread.join()
-
-            # Check if an exception occurred
-            if self.sync_exception:
-                raise self.sync_exception
+            self.sync_result = run(self.args)
 
             result = self.sync_result
         except Exception:

bazarr/subtitles/upload.py

@@ -163,15 +163,15 @@ def manual_upload_subtitle(path, language, forced, hi, media_type, subtitle, aud
     if media_type == 'series':
         sync_subtitles(video_path=path, srt_path=subtitle_path, srt_lang=uploaded_language_code2, percent_score=100,
                        sonarr_series_id=episode_metadata.sonarrSeriesId, forced=forced, hi=hi,
-                       sonarr_episode_id=episode_metadata.sonarrEpisodeId, job_id=job_id, job_sub_function=True,)
+                       sonarr_episode_id=episode_metadata.sonarrEpisodeId, job_id=job_id)
         reversed_path = path_mappings.path_replace_reverse(path)
         reversed_subtitles_path = path_mappings.path_replace_reverse(subtitle_path)
         notify_sonarr(episode_metadata.sonarrSeriesId)
         event_stream(type='series', action='update', payload=episode_metadata.sonarrSeriesId)
         event_stream(type='episode-wanted', action='delete', payload=episode_metadata.sonarrEpisodeId)
     else:
         sync_subtitles(video_path=path, srt_path=subtitle_path, srt_lang=uploaded_language_code2, percent_score=100,
-                       radarr_id=movie_metadata.radarrId, forced=forced, hi=hi, job_id=job_id, job_sub_function=True,)
+                       radarr_id=movie_metadata.radarrId, forced=forced, hi=hi, job_id=job_id)
         reversed_path = path_mappings.path_replace_reverse_movie(path)
         reversed_subtitles_path = path_mappings.path_replace_reverse_movie(subtitle_path)
         notify_radarr(movie_metadata.radarrId)

custom_libs/subliminal_patch/providers/opensubtitlescom.py

@@ -302,26 +302,26 @@ def query(self, languages, video):
         self.video = video
         if self.use_hash:
             file_hash = self.video.hashes.get('opensubtitlescom')
-            logger.debug(f'Searching using this hash: {file_hash}')
         else:
             file_hash = None
+        logger.debug(f'Searching using this hash: {file_hash}')
 
-        if isinstance(self.video, Episode):
-            title = self.video.series
-        else:
-            title = self.video.title
-
-        imdb_id = None
-        if isinstance(self.video, Episode) and self.video.imdb_id:
-            imdb_id = self.sanitize_external_ids(self.video.imdb_id)
-        elif isinstance(self.video, Movie) and self.video.imdb_id:
-            imdb_id = self.sanitize_external_ids(self.video.imdb_id)
+        imdb_id = self.sanitize_external_ids(self.video.imdb_id) if self.video.imdb_id else None
+        logger.debug(f'Searching using this IMDB ID: {imdb_id}')
 
         title_id = None
-        if not imdb_id:
+        if ((isinstance(self.video, Episode) and not self.video.series_imdb_id) or
+                (isinstance(self.video, Movie) and not imdb_id)):
+            if isinstance(self.video, Episode):
+                title = self.video.series
+            else:
+                title = self.video.title
+            logger.debug(f'Searching for this title: {title}')
+
             title_id = self.search_titles(title)
-            if not title_id:
-                return []
+            logger.debug(f'Found this title ID: {title_id}')
+        else:
+            logger.debug(f"No need to search for a title ID. We'll use the IMDB ID instead.")
 
         # be sure to remove duplicates using list(set())
         langs_list = sorted(list(set([to_opensubtitlescom(lang.basename).lower() for lang in languages])))
@@ -331,31 +331,46 @@ def query(self, languages, video):
 
         # define the proper query parameters based on the video type
         # query parameters must be alphabetically ordered to prevent redirect
+        params: list[tuple[str, str | int]] = [('languages', langs)]
+        if file_hash:
+            params.append(('moviehash', file_hash))
+        if imdb_id:
+            params.append(('imdb_id', imdb_id))
+
         if isinstance(self.video, Episode):
-            params = [('episode_number', self.video.episode),
-                      ('imdb_id', imdb_id),
-                      ('languages', langs),
-                      ('moviehash', file_hash),
-                      ('parent_feature_id', title_id),
-                      ('parent_imdb_id', self.sanitize_external_ids(self.video.series_imdb_id) if
-                      self.video.series_imdb_id else None),
-                      ('season_number', self.video.season)]
+            if not imdb_id and not title_id and not self.video.series_imdb_id:
+                logger.debug("We don't have any ID to search for, returning empty list.")
+                return []
+
+            if self.video.episode:
+                params.append(('episode_number', self.video.episode))
+            if self.video.season:
+                params.append(('season_number', self.video.season))
+            if self.video.series_imdb_id:
+                params.append(('parent_imdb_id', self.sanitize_external_ids(self.video.series_imdb_id)))
+            if title_id:
+                params.append(('parent_feature_id', title_id))
         else:
-            params = [('id', title_id),
-                      ('imdb_id', imdb_id),
-                      ('languages', langs),
-                      ('moviehash', file_hash)]
+            if not imdb_id and not title_id:
+                logger.debug("We don't have any ID to search for, returning empty list.")
+                return []
+
+            if title_id:
+                params.append(('id', title_id))
 
         # append the 'exclude' parameter to the list of query parameters if we don't want AI translated subtitles'
         if not self.include_ai_translated:
+            logger.debug("Excluding AI translated subtitles from search results")
             params.append(('ai_translated', 'exclude'))
 
         # append the 'exclude' parameter to the list of query parameters if we want machine translated subtitles'
         if self.include_machine_translated:
+            logger.debug("Including machine translated subtitles in search results")
             params.append(('machine_translated', 'include'))
 
         # sort params alphabetically to prevent redirect
         params = sorted(params, key=lambda param: param[0])
+        logger.info(f'Query parameters used to query OpenSubtitles.com: {params}')
 
         # query the server
         res = self.retry(
@@ -592,25 +607,28 @@ def log_request_response(response, non_standard=True):
     if 'Authorization' in redacted_request_headers and isinstance(redacted_request_headers['Authorization'], str):
         redacted_request_headers['Authorization'] = redacted_request_headers['Authorization'][:-8]+8*'x'
 
+    redacted_request_body = None
     if response.request.body:
-        redacted_request_body = json.loads(response.request.body)
-        if 'password' in redacted_request_body:
-            redacted_request_body['password'] = 'redacted'
-    else:
-        redacted_request_body = None
+        try:
+            redacted_request_body = json.loads(response.request.body)
+        except json.JSONDecodeError:
+            logger.debug(f"Response body could not be parsed as JSON: {response.request.body!r}.")
+        else:
+            if 'password' in redacted_request_body:
+                redacted_request_body['password'] = 'redacted'
 
     redacted_response_body = json.loads(response.text)
     if 'token' in redacted_response_body and isinstance(redacted_response_body['token'], str):
         redacted_response_body['token'] = redacted_response_body['token'][:-8] + 8 * 'x'
 
     if non_standard:
         logger.debug("opensubtitlescom returned a non standard response. Logging request/response for debugging "
-                      "purpose.")
+                     "purpose.")
     else:
         logger.debug("opensubtitlescom returned a standard response. Logging request/response for debugging purpose.")
     logger.debug(f"Request URL: {response.request.url}")
     logger.debug(f"Request Headers: {redacted_request_headers}")
-    logger.debug(f"Request Body: {json.dumps(redacted_request_body)}")
+    logger.debug(f"Request Body: {json.dumps(redacted_request_body) if redacted_request_body else None}")
     logger.debug(f"Response Status Code: {response.status_code}")
     logger.debug(f"Response Headers: {response.headers}")
-    logger.debug(f"Response Body: {json.dumps(redacted_response_body)}")
+    logger.debug(f"Response Body: {json.dumps(redacted_response_body) if redacted_request_body else None}")