Merge development into master

Author: github-actions[bot]

README.md

@@ -83,6 +83,7 @@ If you need something that is not already part of Bazarr, feel free to create a
 - SubsRo
 - Subsunacs.net
 - SubSynchro
+- Subtis
 - Subtitrari-noi.ro
 - subtitri.id.lv
 - Subtitulamos.tv

bazarr.py

@@ -27,8 +27,8 @@ def check_python_version():
         print("Python " + minimum_py3_str + " or greater required. "
               "Current version is " + platform.python_version() + ". Please upgrade Python.")
         exit_program(EXIT_PYTHON_UPGRADE_NEEDED)
-    elif int(python_version[0]) == 3 and int(python_version[1]) > 12:
-        print("Python version greater than 3.12.x is unsupported. Current version is " + platform.python_version() +
+    elif int(python_version[0]) == 3 and int(python_version[1]) > 13:
+        print("Python version greater than 3.13.x is unsupported. Current version is " + platform.python_version() +
               ". Keep in mind that even if it works, you're on your own.")
     elif (int(python_version[0]) == minimum_py3_tuple[0] and int(python_version[1]) < minimum_py3_tuple[1]) or \
             (int(python_version[0]) != minimum_py3_tuple[0]):

bazarr/api/plex/oauth.py

@@ -505,6 +505,7 @@ def get(self):
                     # Collect all connections for parallel testing
                     connection_candidates = []
                     connections = []
+                    all_device_connection_uris = []  # Store ALL URIs before testing
                     for conn in device.get('connections', []):
                         connection_data = {
                             'uri': conn['uri'],
@@ -514,6 +515,7 @@ def get(self):
                             'local': conn.get('local', False)
                         }
                         connection_candidates.append(connection_data)
+                        all_device_connection_uris.append(conn['uri'])  # Store ALL URIs
 
                     # Test all connections in parallel using threads
                     if connection_candidates:
@@ -545,15 +547,28 @@ def test_connection_wrapper(conn_data):
                         connections.sort(key=lambda x: x.get('latency', float('inf')))
                         bestConnection = connections[0] if connections else None
 
-                        servers.append({
+                        server_data = {
                             'name': device['name'],
                             'machineIdentifier': device['clientIdentifier'],
                             'connections': connections,
                             'bestConnection': bestConnection,
                             'version': device.get('productVersion'),
                             'platform': device.get('platform'),
                             'device': device.get('device')
-                        })
+                        }
+                        servers.append(server_data)
+
+                        # Update stored connections if this is the currently selected server
+                        selected_machine_id = settings.plex.get('server_machine_id')
+                        if selected_machine_id and device['clientIdentifier'] == selected_machine_id:
+                            # Store ALL connection URIs (not just the working ones) for round-robin fallback
+                            settings.plex.server_connections = all_device_connection_uris
+                            # Update best connection if it changed
+                            if bestConnection:
+                                settings.plex.server_url = bestConnection['uri']
+                                settings.plex.server_local = bestConnection.get('local', False)
+                            write_config()
+                            logger.debug(f"Auto-updated connections for server {device['name']}: {len(all_device_connection_uris)} total, {len(connections)} available")
 
             return {'data': servers}
 
@@ -571,69 +586,99 @@ def get(self):
         try:
             decrypted_token = get_decrypted_token()
             if not decrypted_token:
-                logger.warning("No decrypted token available for Plex library fetching")
+                logger.debug("No decrypted token available for Plex library fetching")
                 return {'data': []}
 
-            # Get the selected server URL
-            server_url = settings.plex.get('server_url')
-            if not server_url:
-                logger.warning("No Plex server selected")
+            # Get all stored server connections for round-robin fallback
+            primary_url = settings.plex.get('server_url')
+            all_connections = settings.plex.get('server_connections', [])
+            
+            # Build connection list: primary URL first, then others as fallback
+            server_connections = []
+            if primary_url:
+                server_connections.append(primary_url)
+                # Add other connections as fallback (skip duplicates)
+                server_connections.extend([url for url in all_connections if url != primary_url])
+            elif all_connections:
+                server_connections = all_connections
+            else:
+                logger.debug("No Plex server connections available")
                 return {'data': []}
 
-            logger.debug(f"Fetching Plex libraries from server: {sanitize_server_url(server_url)}")
+            logger.debug(f"Fetching Plex libraries for server: {settings.plex.get('server_name', 'Unknown')}")
 
             headers = {
                 'X-Plex-Token': decrypted_token,
                 'Accept': 'application/json'
             }
 
-            # Get libraries from the selected server
-            response = requests.get(
-                f"{server_url}/library/sections",
-                headers=headers,
-                timeout=10,
-                verify=False
-            )
+            # Try each connection in order until one succeeds (round-robin)
+            sections = []
+            successful_server_url = None
+            
+            for idx, server_url in enumerate(server_connections, 1):
+                try:
+                    logger.debug(f"Attempting to fetch libraries from connection {idx}/{len(server_connections)}: {sanitize_server_url(server_url)}")
+                    
+                    # Get libraries from this server URL
+                    lib_response = requests.get(
+                        f"{server_url}/library/sections",
+                        headers=headers,
+                        timeout=10,
+                        verify=False
+                    )
+
+                    if lib_response.status_code in (401, 403):
+                        logger.debug(f"Connection {idx}: Authentication failed ({lib_response.status_code})")
+                        continue
+                    elif lib_response.status_code != 200:
+                        logger.debug(f"Connection {idx}: HTTP {lib_response.status_code}")
+                        continue
 
-            if response.status_code in (401, 403):
-                logger.warning(f"Plex authentication failed: {response.status_code}")
-                return {'data': []}
-            elif response.status_code != 200:
-                logger.error(f"Plex API error: {response.status_code}")
-                raise PlexConnectionError(f"Failed to get libraries: HTTP {response.status_code}")
+                    # Parse the response
+                    lib_content_type = lib_response.headers.get('content-type', '')
+                    
+                    if 'application/json' in lib_content_type:
+                        data = lib_response.json()
+                        if 'MediaContainer' in data and 'Directory' in data['MediaContainer']:
+                            sections = data['MediaContainer']['Directory']
+                    elif 'application/xml' in lib_content_type or 'text/xml' in lib_content_type:
+                        import xml.etree.ElementTree as ET
+                        root = ET.fromstring(lib_response.text)
+                        sections = []
+                        for directory in root.findall('Directory'):
+                            sections.append({
+                                'key': directory.get('key'),
+                                'title': directory.get('title'),
+                                'type': directory.get('type'),
+                                'count': int(directory.get('count', 0)),
+                                'agent': directory.get('agent', ''),
+                                'scanner': directory.get('scanner', ''),
+                                'language': directory.get('language', ''),
+                                'uuid': directory.get('uuid', ''),
+                                'updatedAt': int(directory.get('updatedAt', 0)),
+                                'createdAt': int(directory.get('createdAt', 0))
+                            })
+                    
+                    # If we got sections, this connection worked
+                    if sections:
+                        successful_server_url = server_url
+                        logger.debug(f"Successfully fetched libraries from connection {idx}/{len(server_connections)}")
+                        break
+                    else:
+                        logger.debug(f"Connection {idx}: No sections returned")
+                        
+                except requests.exceptions.RequestException as e:
+                    logger.debug(f"Connection {idx} failed: {type(e).__name__}: {str(e)}")
+                    continue
+                except Exception as e:
+                    logger.debug(f"Connection {idx} error: {type(e).__name__}: {str(e)}")
+                    continue
 
-            response.raise_for_status()
-            
-            # Parse the response - it could be JSON or XML depending on the server
-            content_type = response.headers.get('content-type', '')
-            logger.debug(f"Plex libraries response content-type: {content_type}")
-            
-            if 'application/json' in content_type:
-                data = response.json()
-                logger.debug(f"Plex libraries JSON response: {data}")
-                if 'MediaContainer' in data and 'Directory' in data['MediaContainer']:
-                    sections = data['MediaContainer']['Directory']
-                else:
-                    sections = []
-            elif 'application/xml' in content_type or 'text/xml' in content_type:
-                import xml.etree.ElementTree as ET
-                root = ET.fromstring(response.text)
-                sections = []
-                for directory in root.findall('Directory'):
-                    sections.append({
-                        'key': directory.get('key'),
-                        'title': directory.get('title'),
-                        'type': directory.get('type'),
-                        'count': int(directory.get('count', 0)),
-                        'agent': directory.get('agent', ''),
-                        'scanner': directory.get('scanner', ''),
-                        'language': directory.get('language', ''),
-                        'uuid': directory.get('uuid', ''),
-                        'updatedAt': int(directory.get('updatedAt', 0)),
-                        'createdAt': int(directory.get('createdAt', 0))
-                    })
-            else:
-                raise PlexConnectionError(f"Unexpected response format: {content_type}")
+            # If no connection succeeded, return empty
+            if not successful_server_url or not sections:
+                logger.warning(f"Failed to fetch libraries from all {len(server_connections)} connection(s)")
+                return {'data': []}
 
             # Filter and format libraries for movie and show types only
             libraries = []
@@ -643,7 +688,7 @@ def get(self):
                     try:
                         section_key = section.get('key')
                         count_response = requests.get(
-                            f"{server_url}/library/sections/{section_key}/all",
+                            f"{successful_server_url}/library/sections/{section_key}/all",
                             headers={'X-Plex-Token': decrypted_token, 'Accept': 'application/json'},
                             timeout=5,
                             verify=False
@@ -674,10 +719,10 @@ def get(self):
                         'uuid': section.get('uuid', ''),
                         'updatedAt': int(section.get('updatedAt', 0)),
                         'createdAt': int(section.get('createdAt', 0)),
-                        'locations': _get_library_locations(server_url, section_key, decrypted_token)
+                        'locations': _get_library_locations(successful_server_url, section_key, decrypted_token)
                     })
 
-            logger.debug(f"Filtered Plex libraries: {libraries}")
+            logger.debug(f"Successfully retrieved {len(libraries)} movie/show libraries from Plex")
             return {'data': libraries}
 
         except requests.exceptions.RequestException as e:
@@ -836,6 +881,7 @@ def get(self):
     post_request_parser.add_argument('name', type=str, required=True, help='Server name')
     post_request_parser.add_argument('uri', type=str, required=True, help='Connection URI')
     post_request_parser.add_argument('local', type=str, required=False, default='false', help='Is local connection')
+    post_request_parser.add_argument('connections', type=list, location='json', required=False, help='All available connection URIs')
 
     @api_ns_plex.doc(parser=post_request_parser)
     def post(self):
@@ -844,11 +890,14 @@ def post(self):
         name = args.get('name')
         connection_uri = args.get('uri')
         connection_local = args.get('local', 'false').lower() == 'true'
+        connections = args.get('connections', [])
 
         settings.plex.server_machine_id = machine_identifier
         settings.plex.server_name = name
         settings.plex.server_url = connection_uri
         settings.plex.server_local = connection_local
+        # Store all connection URIs for round-robin fallback
+        settings.plex.server_connections = connections if connections else [connection_uri]
         write_config()
 
         return {
@@ -904,13 +953,12 @@ def post(self):
             instance_name = settings.general.get('instance_name', 'Bazarr')
             instance_param = quote_plus(instance_name)
 
+            scheme = 'https' if request.is_secure else 'http'
+            host = request.host
             if configured_base_url:
-                webhook_url = f"{configured_base_url}/api/webhooks/plex?apikey={apikey}&instance={instance_param}"
-                logger.info(f"Using configured base URL for webhook: {configured_base_url}/api/webhooks/plex (instance: {instance_name})")
+                webhook_url = f"{scheme}://{host}{configured_base_url}/api/webhooks/plex?apikey={apikey}&instance={instance_param}"
+                logger.info(f"Using configured base URL for webhook: {scheme}://{host}{configured_base_url}/api/webhooks/plex (instance: {instance_name})")
             else:
-                # Fall back to using the current request's host
-                scheme = 'https' if request.is_secure else 'http'
-                host = request.host
                 webhook_url = f"{scheme}://{host}/api/webhooks/plex?apikey={apikey}&instance={instance_param}"
                 logger.info(f"Using request host for webhook (no base URL configured): {scheme}://{host}/api/webhooks/plex (instance: {instance_name})")
                 logger.info("Note: If Bazarr is behind a reverse proxy, configure Base URL in General Settings for better reliability")

bazarr/api/system/jobs.py

@@ -6,7 +6,7 @@
 
 from ..utils import authenticate
 
-api_ns_system_jobs = Namespace('System Jobs', description='List or delete jobs from the queue')
+api_ns_system_jobs = Namespace('System Jobs', description='List, force start, move or delete jobs from the queue')
 
 
 @api_ns_system_jobs.route('system/jobs')
@@ -40,6 +40,28 @@ def get(self):
         return marshal(jobs_queue.list_jobs_from_queue(job_id=job_id, status=status), self.get_response_model,
                        envelope='data')
 
+    post_request_parser = reqparse.RequestParser()
+    post_request_parser.add_argument('id', type=int, required=True, help='Job ID act onto')
+    post_request_parser.add_argument('action', type=str, required=True,
+                                     help='Action to perform from ["force_start", "move_top", "move_bottom"]')
+
+    @authenticate
+    @api_ns_system_jobs.doc(parser=post_request_parser)
+    @api_ns_system_jobs.response(204, 'Success')
+    @api_ns_system_jobs.response(401, 'Not Authenticated')
+    def post(self):
+        """Force start, move to top or move to bottom of the queue a specific job"""
+        args = self.post_request_parser.parse_args()
+        job_id = args.get('id')
+        action = args.get('action')
+        if action == "force_start":
+            jobs_queue.force_start_pending_job(job_id=job_id)
+        elif action == "move_top":
+            jobs_queue.move_job_in_pending_queue(job_id=job_id, move_destination="top")
+        elif action == "move_bottom":
+            jobs_queue.move_job_in_pending_queue(job_id=job_id, move_destination="bottom")
+        return '', 204
+
     patch_request_parser = reqparse.RequestParser()
     patch_request_parser.add_argument('queueName', type=str, required=True, help='Jobs queue name to empty',
                                       choices=['pending', 'failed', 'completed'])

bazarr/api/system/status.py

@@ -62,5 +62,6 @@ def get(self):
         system_status.update({'bazarr_config_directory': args.config_dir})
         system_status.update({'start_time': startTime})
         system_status.update({'timezone': timezone})
+        system_status.update({'cpu_cores': os.cpu_count()})
 
         return {'data': system_status}

bazarr/app/announcements.py

@@ -56,12 +56,12 @@ def get_announcements_to_file(job_id=None, startup=False):
 
     try:
         r = requests.get(
-            url="https://cdn.statically.io/gh/morpheus65535/bazarr-binaries@refs/heads/master/announcements.json",
+            url="https://cdn.jsdelivr.net/gh/morpheus65535/bazarr-binaries@latest/announcements.json",
             timeout=30
         )
     except Exception:
         try:
-            logging.exception("Error trying to get announcements from Statically, falling back to Github.")
+            logging.exception("Error trying to get announcements from jsdelivr.net, falling back to Github.")
             r = requests.get(
                 url="https://raw.githubusercontent.com/morpheus65535/bazarr-binaries/refs/heads/master/announcements.json",
                 timeout=30
@@ -79,7 +79,7 @@ def get_announcements_to_file(job_id=None, startup=False):
 
 def get_online_announcements():
     try:
-        with open(os.path.join(args.config_dir, 'config', 'announcements.json'), 'r') as f:
+        with open(os.path.join(args.config_dir, 'config', 'announcements.json'), 'r', encoding='utf-8') as f:
             data = json.load(f)
     except (OSError, json.JSONDecodeError):
         return []
@@ -96,17 +96,6 @@ def get_online_announcements():
 def get_local_announcements():
     announcements = []
 
-    # opensubtitles.org end-of-life
-    enabled_providers = get_enabled_providers()
-    if enabled_providers and 'opensubtitles' in enabled_providers and not settings.opensubtitles.vip:
-        announcements.append({
-            'text': 'Opensubtitles.org is deprecated for non-VIP users, migrate to Opensubtitles.com ASAP and disable '
-                    'this provider to remove this announcement.',
-            'link': 'https://wiki.bazarr.media/Troubleshooting/OpenSubtitles-migration/',
-            'dismissible': False,
-            'timestamp': 1676236978,
-        })
-
     # deprecated Sonarr and Radarr versions
     if get_sonarr_info.is_deprecated():
         announcements.append({