Fonction de recherche de films ou de séries dans vstream

[Ayuzerak]

Quelle fonction est appelée quand on lance streaming/search/search (movies) ou streaming/search/search (tv shows) ?

[detobel36]

Salut,

Pourquoi ?

Sinon pour te répondre, il me semble que ce n'est pas qu'une fonction... Toutes les requêtes arrivent dans default.py:

venom-xbmc-addons/plugin.video.vstream/default.py

Line 124 in 4bd8ea9

if isSearch(sSiteName, sFunction):

De la, je te laisse regarder les méthodes qui sont appelées...

[Ayuzerak]

J'essai de faire une fonction searchGlobal qui lance le premier lien valide de showHosters() trouvé. J'obtiens quelques informations comme le nom de la fonction 'showHosters' mais je n'arrive pas à récupérer les liens trouvés.

    def searchGlobalPlay(self, sSearchText='', sCat='movie'):
        xbmc.executebuiltin("Notification(VStream,Recherche VStream en cours)")
        VSlog('Starting searchGlobalPlay')
        try:
            # Validation du type de contenu
            if sCat not in ["movie", "series"]:
                VSlog('Invalid content type')
                return {"error": "Invalid content type. Use 'movie' or 'series'."}
            sSearchText=''
            # Charger un titre aléatoire si aucun nom n'est fourni
            if not sSearchText:
                json_file = FILMS_JSON if sCat == "movie" else SERIES_JSON
                try:
                    with open(json_file, "r", encoding="utf-8") as f:
                        suggestions = json.load(f)
                    sSearchText = random.choice(suggestions)  # Utiliser le premier élément comme titre par défaut
                    VSlog(f'Loaded random title: {sSearchText}')
                except (FileNotFoundError, json.JSONDecodeError):
                    VSlog(f'Unable to load suggestions from {json_file}')
                    return {"error": f"Unable to load suggestions from {json_file}"}

            oGui, listPlugins = self._performSearch(sSearchText, sCat)
            if not oGui or not listPlugins:
                VSlog('No GUI or plugins returned from _performSearch')
                return True

            searchResults = self._processResults(oGui, listPlugins)
            if not searchResults:
                VSlog('No search results to process')
                return True

            # Play the first valid hoster link
            for pluginResults in searchResults.values():
                for result in pluginResults:
                    hosterGui = cHosterGui()
                    VSlog(f"Hoster Link Details:")
                    guiElement = result['guiElement']
                    VSlog(f"Hoster Link Details:")
                    VSlog(f"  - Title: {guiElement.getTitle()}")
                    VSlog(f"  - Media URL: {guiElement.getMediaUrl()}")
                    VSlog(f"  - Host: {guiElement.getSiteName()}")
                    VSlog(f"  - Quality: {guiElement.getRes()}")
                    VSlog(f"  - Description: {guiElement.getDescription()}")
                    VSlog(f"  - Genre: {guiElement.getGenre()}")
                    VSlog(f"  - Release Year: {guiElement.getYear()}")
                    VSlog(f"  - Season: {guiElement.getSeason()}")
                    VSlog(f"  - Episode: {guiElement.getEpisode()}")
                    VSlog(f"  - Thumbnail URL: {guiElement.getThumbnail()}")
                    VSlog(f"  - Poster URL: {guiElement.getPoster()}")
                    VSlog(f"  - Fanart URL: {guiElement.getFanart()}")
                    VSlog(f"  - Function: {guiElement.getFunction()}")
                    
                    # Log the values of __aItemValues VSlog("Item Values:")
                    for key, value in guiElement.getItemValues().items(): 
                        VSlog(f" - {key}: {value}") 
                    # Log the values of __aProperties VSlog("Properties:") 
                    for key, value in guiElement.getItemProperties().items(): 
                        VSlog(f" - {key}: {value}") 
                    # Log the context elements VSlog("Context Elements:") 
                    for element in guiElement.getContextItems(): 
                        VSlog(f" - {element}")
                        
                    hoster = hosterGui.checkHoster(guiElement.getMediaUrl())  # Check if the link is valid
                    if hoster:  # Found a valid hoster
                        VSlog(f"Playing first valid hoster link: {hoster}")
                        hosterGui.playHoster(hoster)  # Play the link
                        return True

            oGui.addText('globalSearch', "No valid hoster link found.", 'search.png')
            cGui.CONTENT = 'files'
            oGui.setEndOfDirectory()
            VSlog('Set end of directory for GUI')
        except Exception as error:
            VSlog(f'Error in searchGlobalPlay: {error}')
            traceback.print_exc()
            self._progressForceClose()

        VSlog('searchGlobalPlay completed')
        return True

[Ayuzerak]

L'ensemble du fichier search.py: ```

-- coding: utf-8 --

vStream https://github.com/Kodi-vStream/venom-xbmc-addons

import traceback
import threading
import xbmc
import json
import random

from resources.lib.gui.gui import cGui
from resources.lib.gui.hoster import cHosterGui #systeme de recherche pour l'hote
from resources.lib.handler.rechercheHandler import cRechercheHandler
from resources.lib.handler.inputParameterHandler import cInputParameterHandler
from resources.lib.comaddon import progress, VSlog, addon, window, VSPath
from resources.lib.util import Quote

Chemins vers les fichiers JSON des films et séries les plus récents

FILMS_JSON = VSPath('special://home/addons/plugin.video.vstream/20filmslesplusrecents.json')
SERIES_JSON = VSPath('special://home/addons/plugin.video.vstream/20serieslesplusrecents.json')

class cSearch:

def __init__(self):
    VSlog('Initializing cSearch')
    self.addons = addon()
    VSlog('Addon initialized')

def _performSearch(self, sSearchText, sCat):
    """Helper method to handle common search logic."""
    VSlog(f'Starting _performSearch with sSearchText: {sSearchText}, sCat: {sCat}')
    sSearchText = sSearchText.replace(':', ' ')
    VSlog(f'Formatted sSearchText: {sSearchText}')
    listPlugins = self._initSearch(sSearchText, sCat)
    VSlog(f'Initialized search with plugins: {listPlugins}')

    if len(listPlugins) == 0:
        VSlog('No plugins found for search')
        return None, None

    VSlog('Launching search threads')
    listThread = self._launchSearch(listPlugins, self._pluginSearch, [Quote(sSearchText), True])
    VSlog(f'Launched search threads: {listThread}')
    self._finishSearch(listThread)
    VSlog('Finished search threads')

    oGui = cGui()
    VSlog('Creating GUI object')
    oGui.addText('globalSearch', self.addons.VSlang(30081) % sSearchText, 'search.png')
    VSlog('Added search text to GUI')

    VSlog('Search performed successfully')
    return oGui, listPlugins

def _processResults(self, oGui, listPlugins):
    """Helper method to process search results."""
    VSlog('Starting _processResults')
    searchResults = oGui.getSearchResult()
    VSlog(f'Search results obtained: {searchResults}')
    total = sum(len(results) for results in searchResults.values())
    VSlog(f'Total results found: {total}')

    if not total:
        VSlog('No results found')
        oGui.addText('globalSearch', "No results found.", 'search.png')
        return None

    xbmc.sleep(500)  # Pause for visual continuity
    VSlog('Sleeping for 500ms')
    progressMeta = progress().VScreate(self.addons.VSlang(30076), large=total > 50)
    VSlog(f'Progress meta created: {progressMeta}')
    count = 0

    for plugin in listPlugins:
        pluginId = plugin['identifier']
        VSlog(f'Processing plugin: {pluginId}')
        if pluginId in searchResults and searchResults[pluginId]:  # Plugin has results
            count += 1
            VSlog(f'Adding plugin {pluginId} to GUI with count: {count}')
            oGui.addText(pluginId, f"{count}. [COLOR olive]{plugin['name']}[/COLOR]", f"sites/{pluginId}.png")

            for result in searchResults[pluginId]:
                progressMeta.VSupdate(progressMeta, total)
                VSlog(f'Updated progress meta: {progressMeta}')
                if progressMeta.iscanceled():
                    VSlog('Search canceled by user')
                    break
                oGui.addFolder(result['guiElement'], result['params'])
                VSlog(f'Added folder to GUI: {result["guiElement"]}')

            if progressMeta.iscanceled():
                VSlog('Breaking out of plugin result loop due to cancellation')
                break

    progressMeta.VSclose(progressMeta)
    VSlog('Progress meta closed')
    VSlog('Results processed successfully')
    return searchResults

def searchGlobal(self, sSearchText='', sCat=''):
    VSlog('Starting searchGlobal')
    try:
        if not sSearchText:
            oInputParameterHandler = cInputParameterHandler()
            VSlog('Created input parameter handler')
            sSearchText = oInputParameterHandler.getValue('searchtext')
            sCat = oInputParameterHandler.getValue('sCat')
            VSlog(f'Input parameters obtained: sSearchText={sSearchText}, sCat={sCat}')

        oGui, listPlugins = self._performSearch(sSearchText, sCat)
        if not oGui or not listPlugins:
            VSlog('No GUI or plugins returned from _performSearch')
            return True

        self._processResults(oGui, listPlugins)
        VSlog('Processed search results')
        cGui.CONTENT = 'files'
        oGui.setEndOfDirectory()
        VSlog('Set end of directory for GUI')
    except Exception as error:
        VSlog(f'Error in searchGlobal: {error}')
        traceback.print_exc()
        self._progressForceClose()

    VSlog('searchGlobal completed')
    return True

def searchGlobalPlay(self, sSearchText='', sCat='movie'):
    xbmc.executebuiltin("Notification(VStream,Recherche VStream en cours)")
    VSlog('Starting searchGlobalPlay')
    try:
        # Validation du type de contenu
        if sCat not in ["movie", "series"]:
            VSlog('Invalid content type')
            return {"error": "Invalid content type. Use 'movie' or 'series'."}
        sSearchText=''
        # Charger un titre aléatoire si aucun nom n'est fourni
        if not sSearchText:
            json_file = FILMS_JSON if sCat == "movie" else SERIES_JSON
            try:
                with open(json_file, "r", encoding="utf-8") as f:
                    suggestions = json.load(f)
                sSearchText = random.choice(suggestions)  # Utiliser le premier élément comme titre par défaut
                VSlog(f'Loaded random title: {sSearchText}')
            except (FileNotFoundError, json.JSONDecodeError):
                VSlog(f'Unable to load suggestions from {json_file}')
                return {"error": f"Unable to load suggestions from {json_file}"}

        oGui, listPlugins = self._performSearch(sSearchText, sCat)
        if not oGui or not listPlugins:
            VSlog('No GUI or plugins returned from _performSearch')
            return True

        searchResults = self._processResults(oGui, listPlugins)
        if not searchResults:
            VSlog('No search results to process')
            return True

        # Play the first valid hoster link
        for pluginResults in searchResults.values():
            for result in pluginResults:
                hosterGui = cHosterGui()
                VSlog(f"Hoster Link Details:")
                guiElement = result['guiElement']
                VSlog(f"Hoster Link Details:")
                VSlog(f"  - Title: {guiElement.getTitle()}")
                VSlog(f"  - Media URL: {guiElement.getMediaUrl()}")
                VSlog(f"  - Host: {guiElement.getSiteName()}")
                VSlog(f"  - Quality: {guiElement.getRes()}")
                VSlog(f"  - Description: {guiElement.getDescription()}")
                VSlog(f"  - Genre: {guiElement.getGenre()}")
                VSlog(f"  - Release Year: {guiElement.getYear()}")
                VSlog(f"  - Season: {guiElement.getSeason()}")
                VSlog(f"  - Episode: {guiElement.getEpisode()}")
                VSlog(f"  - Thumbnail URL: {guiElement.getThumbnail()}")
                VSlog(f"  - Poster URL: {guiElement.getPoster()}")
                VSlog(f"  - Fanart URL: {guiElement.getFanart()}")
                VSlog(f"  - Function: {guiElement.getFunction()}")
                
                # Log the values of __aItemValues VSlog("Item Values:")
                for key, value in guiElement.getItemValues().items(): 
                    VSlog(f" - {key}: {value}") 
                # Log the values of __aProperties VSlog("Properties:") 
                for key, value in guiElement.getItemProperties().items(): 
                    VSlog(f" - {key}: {value}") 
                # Log the context elements VSlog("Context Elements:") 
                for element in guiElement.getContextItems(): 
                    VSlog(f" - {element}")
                    
                hoster = hosterGui.checkHoster(guiElement.getMediaUrl())  # Check if the link is valid
                if hoster:  # Found a valid hoster
                    VSlog(f"Playing first valid hoster link: {hoster}")
                    hosterGui.playHoster(hoster)  # Play the link
                    return True

        oGui.addText('globalSearch', "No valid hoster link found.", 'search.png')
        cGui.CONTENT = 'files'
        oGui.setEndOfDirectory()
        VSlog('Set end of directory for GUI')
    except Exception as error:
        VSlog(f'Error in searchGlobalPlay: {error}')
        traceback.print_exc()
        self._progressForceClose()

    VSlog('searchGlobalPlay completed')
    return True

def _progressInit(self):
    VSlog('Initializing progress')
    self.progress_ = progress().VScreate(large=True)
    VSlog('Progress initialized')

def _progressUpdate(self):
    VSlog('Updating progress')
    searchResults = cGui().getSearchResult()
    numberResult = 0
    values = searchResults.values()
    for result in values:
        numberResult += len(result)
    message = "\n"
    message += (self.addons.VSlang(31209) % numberResult)
    message += "\n"
    message += (self.addons.VSlang(31208) % (", ".join(self.listRemainingPlugins[0:7])))
    if len(self.listRemainingPlugins) > 7:
        message += ", ..."
    self.progress_.VSupdate(self.progress_, self.progressTotal, message, True)
    VSlog(f'Progress updated: {message}')

def _progressClose(self):
    VSlog('Closing progress')
    self.progress_.VSclose(self.progress_)
    VSlog('Progress closed')

def _progressForceClose(self):
    VSlog('Forcing progress close')
    progress().VSclose()
    VSlog('Progress force-closed')

def _getAvailablePlugins(self, searchText, categorie):
    VSlog(f'Getting available plugins for searchText: {searchText}, categorie: {categorie}')
    oHandler = cRechercheHandler()
    VSlog('Created recherche handler')
    oHandler.setText(searchText)
    oHandler.setCat(categorie)
    VSlog('Recherche handler set with text and category')
    return oHandler.getAvailablePlugins()

def _initSearch(self, searchText, searchCat):
    VSlog(f'Initializing search with searchText: {searchText}, searchCat: {searchCat}')
    try:
        listPlugins = self._getAvailablePlugins(searchText, searchCat)
        if not listPlugins:
            VSlog('No plugins available')
            return []

        self.progressTotal = len(listPlugins)
        self._progressInit()

        self.listRemainingPlugins = [plugin['name'] for plugin in listPlugins]
        cGui().resetSearchResult()
        VSlog(f'Search initialized with plugins: {listPlugins}')
        return listPlugins
    except Exception as error:
        VSlog(f'Error when search is initiated: {error}')
        traceback.print_exc()
        self._progressForceClose()
        return []

def _launchSearch(self, listPlugins, targetFunction, argsList):
    VSlog(f'Launching search with plugins: {listPlugins}')
    listThread = []
    window(10101).setProperty('search', 'true')
    for plugin in listPlugins:
        VSlog(f'Starting thread for plugin: {plugin["name"]}')
        thread = threading.Thread(target=targetFunction, name=plugin['name'], args=tuple([plugin] + argsList))
        thread.start()
        listThread.append(thread)
        VSlog(f'Thread started for plugin: {plugin["name"]}')

    VSlog(f'All threads launched: {listThread}')
    return listThread

def _finishSearch(self, listThread):
    VSlog('Finishing search')
    # On attend que les thread soient finis
    for thread in listThread:
        VSlog(f'Joining thread: {thread.name}')
        thread.join()
        VSlog(f'Thread joined: {thread.name}')

    window(10101).setProperty('search', 'false')
    VSlog('Search finished')

def _pluginSearch(self, plugin, sSearchText, updateProcess=False):
    VSlog(f'Starting plugin search for plugin: {plugin["name"]} with searchText: {sSearchText}')
    try:
        plugins = __import__('resources.sites.%s' % plugin['identifier'], fromlist=[plugin['identifier']])
        function = getattr(plugins, plugin['search'][1])
        sUrl = plugin['search'][0] + str(sSearchText)
        VSlog(f'Calling search function for plugin: {plugin["name"]} with URL: {sUrl}')

        function(sUrl)
        if updateProcess:
            self.listRemainingPlugins.remove(plugin['name'])
            self._progressUpdate()
            VSlog(f'Updated progress for plugin: {plugin["name"]}')

        VSlog(f'Search completed for plugin: {plugin["identifier"]}')
    except Exception as e:
        VSlog(f'{plugin["identifier"]}: search failed ({str(e)})')
        traceback.print_exc()
        VSlog(f'Exception traceback: {traceback.format_exc()}')

[detobel36]

T'embête pas, je l'ai déjà fais ici: #3447
Il faut rebase la PR

Mais dans cette pull request, je propose de modifier les fichiers pour permettre en un appel de faire tous les appels récursifs.
Et a la fin du coup, tu peux l'appeler avec un player genre TMDBHelper

[sizanic]

Je n'ai pas oublié ta proposition, et j'y repense parfois lorsque je dois prioriser les évolutions/corrections.
Faudrait que je m'y mette un jour pour une relecture et qu'on finalise ça ensemble.

[Ayuzerak]

J'ai essayé d'appliquer les modifs sur la nouvelle mise à jour mais j'obtiens l'erreur suivante dans les logs, je ne comprends pas pourquoi j'obtiens false dans la variable sMediaUrl hoster.py: play():
2025-01-08 10:19:48.338 T:3052 info : [PLUGIN] vStream: Search function 'showMovies' executed successfully.
2025-01-08 10:19:48.338 T:3052 info : [PLUGIN] vStream: Search completed for plugin: SeeFrench (ID: seefrench)
2025-01-08 10:19:48.339 T:3052 info : [PLUGIN] vStream: Search results for plugin SeeFrench (ID: seefrench): {'seefrench': [{'guiElement': <resources.lib.gui.guiElement.cGuiElement object at 0x0000015741C9E5B0>, 'params': <resources.lib.handler.outputParameterHandler.cOutputParameterHandler object at 0x0000015741C9E730>}]}
2025-01-08 10:19:48.339 T:3052 info : [PLUGIN] vStream: Results found for plugin SeeFrench: [{'guiElement': <resources.lib.gui.guiElement.cGuiElement object at 0x0000015741C9E5B0>, 'params': <resources.lib.handler.outputParameterHandler.cOutputParameterHandler object at 0x0000015741C9E730>}]
2025-01-08 10:19:48.339 T:3052 info : [PLUGIN] vStream: Added plugin name to search result parameters: <resources.lib.handler.outputParameterHandler.cOutputParameterHandler object at 0x0000015741C9E730>
2025-01-08 10:19:48.339 T:3052 info : [PLUGIN] vStream: Starting deep search loop for search result: {'guiElement': <resources.lib.gui.guiElement.cGuiElement object at 0x0000015741C9E5B0>, 'params': <resources.lib.handler.outputParameterHandler.cOutputParameterHandler object at 0x0000015741C9E730>} with search info: {'title': 'Avatar La Voie de l eau', 'cat': 1, 'year': ''}
2025-01-08 10:19:48.339 T:3052 info : [PLUGIN] vStream: Checking if search should continue
2025-01-08 10:19:48.339 T:3052 info : [PLUGIN] vStream: Abort requested: False
2025-01-08 10:19:48.339 T:3052 info : [PLUGIN] vStream: AutoPlayVideo is enabled, progress bar not checked for cancellation.
2025-01-08 10:19:48.339 T:3052 info : [PLUGIN] vStream: Search should continue
2025-01-08 10:19:48.339 T:3052 info : [PLUGIN] vStream: Calculating score for the result:
2025-01-08 10:19:48.339 T:3052 info : [PLUGIN] vStream: Search info: {'title': 'Avatar La Voie de l eau', 'cat': 1, 'year': ''}
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Result params: <resources.lib.handler.outputParameterHandler.cOutputParameterHandler object at 0x0000015741C9E730>
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Checking year correctness:
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Search Year: , Result Year: False
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Result year is missing. Defaulting to neutral (1).
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Year score: 1
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Checking movie title correctness:
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Search title: Avatar La Voie de l eau, Result title: Avatar : La Voie de l'eau
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Checking if all words in search title are in result title.
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Original search title: 'Avatar La Voie de l eau', Result title: 'Avatar : La Voie de l'eau'
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Lowercased search title: 'avatar la voie de l eau', Lowercased result title: 'avatar : la voie de l'eau'
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Word 'avatar' found in result title.
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Word 'la' found in result title.
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Word 'voie' found in result title.
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Word 'de' found in result title.
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Word 'l' found in result title.
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Word 'eau' found in result title.
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: All words in the search title are present in the result title.
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: Original word: Avatar : La Voie de l'eau
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: After replacing non-alphanumeric characters: Avatar La Voie de l eau
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: After normalizing 'éèêë' to 'e': Avatar La Voie de l eau
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: After normalizing 'à' to 'a': Avatar La Voie de l eau
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: After normalizing 'ô' to 'o': Avatar La Voie de l eau
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: After normalizing 'ù' to 'u': Avatar La Voie de l eau
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: After normalizing 'œ' to 'oe': Avatar La Voie de l eau
2025-01-08 10:19:48.340 T:3052 info : [PLUGIN] vStream: After removing extra spaces: Avatar La Voie de l eau
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: All search words found in result title. Normalized titles for comparison:
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Normalized Search Title: avatar la voie de l eau
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Normalized Result Title: avatar la voie de l eau
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Exact title match found.
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Title score: 2
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Checking language correctness:
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Result language: false, AutoPlay language setting: 0
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Result language is empty or marked as 'false'. Defaulting to neutral.
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Language correctness check resulted in no match.
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Language score: 0
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Checking category correctness:
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Search category: 1, Result meta: 1
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Category is correct.
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Category score: 1
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Total score for this result: 5
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Number of criteria met: 5
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Processing result from site: seefrench with function: showHosters
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Added result to allVideoLink with criteria: 5
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Auto-play video as it matches the maximum number of criteria
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Checking if search should continue
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Abort requested: False
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: AutoPlayVideo is enabled, progress bar not checked for cancellation.
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Search should continue
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Removed plugin SeeFrench from remaining plugins list.
2025-01-08 10:19:48.341 T:3052 info : [PLUGIN] vStream: Updated progress bar with current search results.
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Attempting to auto-play video links with criteria score: 5
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Found video links with criteria score: 5
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Processing search result: {'guiElement': <resources.lib.gui.guiElement.cGuiElement object at 0x0000015741C9E5B0>, 'params': <resources.lib.handler.outputParameterHandler.cOutputParameterHandler object at 0x0000015741C9E730>}
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Checking if search should continue
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Abort requested: False
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: AutoPlayVideo is enabled, progress bar not checked for cancellation.
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Search should continue
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Search should continue and result has not been tested yet
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Marked result as tested
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Initializing hoster GUI import for function 'play' with parameters: [<resources.lib.handler.outputParameterHandler.cOutputParameterHandler object at 0x0000015741C9E730>, True]
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Successfully imported cHosterGui class.
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Successfully retrieved function 'play' from cHosterGui.
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Calling function 'play' with parameters: [<resources.lib.handler.outputParameterHandler.cOutputParameterHandler object at 0x0000015741C9E730>, True]
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: hoster.py: play
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: oInputParameterHandler: <resources.lib.handler.outputParameterHandler.cOutputParameterHandler object at 0x0000015741C9E730>
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: sHosterIdentifier: False
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: sMediaUrl: False
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: bGetRedirectUrl: False
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: sFileName: False
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: sTitle: False
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: siteUrl: api/movie/m/76600/player
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: sCat: False
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: sMeta: 1
2025-01-08 10:19:48.342 T:1632 info : [PLUGIN] vStream: Error occurred while executing 'play' in _playHosterGui: can only concatenate str (not "bool") to str
2025-01-08 10:19:48.392 T:1632 error : Traceback (most recent call last):

2025-01-08 10:19:48.392 T:1632 error :
2025-01-08 10:19:48.392 T:1632 error : File "C:\Users\adrien\AppData\Roaming\Kodi\addons\plugin.video.vstream\resources\lib\gui\hoster.py", line 419, in play
mediaDisplay = sMediaUrl.split('/')

2025-01-08 10:19:48.392 T:1632 error :
2025-01-08 10:19:48.392 T:1632 error : AttributeError: 'bool' object has no attribute 'split'

2025-01-08 10:19:48.392 T:1632 error :
2025-01-08 10:19:48.392 T:1632 error :
During handling of the above exception, another exception occurred:

2025-01-08 10:19:48.392 T:1632 error :
2025-01-08 10:19:48.392 T:1632 error : Traceback (most recent call last):

2025-01-08 10:19:48.392 T:1632 error :
2025-01-08 10:19:48.392 T:1632 error : File "C:\Users\adrien\AppData\Roaming\Kodi\addons\plugin.video.vstream\resources\lib\search.py", line 1093, in _playHosterGui
result = function(*parameters)

2025-01-08 10:19:48.392 T:1632 error :
2025-01-08 10:19:48.392 T:1632 error : File "C:\Users\adrien\AppData\Roaming\Kodi\addons\plugin.video.vstream\resources\lib\gui\hoster.py", line 422, in play
VSlog('Hoster - play : ' + sMediaUrl)

2025-01-08 10:19:48.392 T:1632 error :
2025-01-08 10:19:48.392 T:1632 error : TypeError: can only concatenate str (not "bool") to str

2025-01-08 10:19:48.392 T:1632 error :
2025-01-08 10:19:48.392 T:1632 info : [PLUGIN] vStream: Attempted to play video, result: None
2025-01-08 10:19:48.392 T:1632 info : [PLUGIN] vStream: Checking if search should continue
2025-01-08 10:19:48.392 T:1632 info : [PLUGIN] vStream: Abort requested: False
2025-01-08 10:19:48.393 T:1632 info : [PLUGIN] vStream: AutoPlayVideo is enabled, progress bar not checked for cancellation.
2025-01-08 10:19:48.393 T:1632 info : [PLUGIN] vStream: Search should continue
2025-01-08 10:19:48.413 T:6512 info : [PLUGIN] vStream: Search function 'showMovies' executed successfully

[Ayuzerak]

le fichier search.py correspondant:

# -*- coding: utf-8 -*-
# vStream https://github.com/Kodi-vStream/venom-xbmc-addons
import re
import traceback
import threading
import xbmc
import json
import random

from resources.lib.gui.gui import cGui
from resources.lib.handler.rechercheHandler import cRechercheHandler
from resources.lib.handler.inputParameterHandler import cInputParameterHandler
from resources.lib.comaddon import progress, VSlog, addon, window, VSPath
from resources.lib.util import Quote

SITE_IDENTIFIER = 'cSearch'
SITE_NAME = 'Search'

# Chemins vers les fichiers JSON des films et séries les plus récents
FILMS_JSON = VSPath('special://home/addons/plugin.video.vstream/20filmslesplusrecents.json')
SERIES_JSON = VSPath('special://home/addons/plugin.video.vstream/20serieslesplusrecents.json')

class cSearch:

    MAX_NUMBER_CRITERIA = 5

    def __init__(self):
        self.addons = addon()
        self.autoPlayVideo = False
        self.findAndPlay = False
        self.allVideoLink = {}

    def load(self):
        """
        Sets the end of the directory for the GUI.
        """
        VSlog("Setting end of directory for GUI.")
        cGui().setEndOfDirectory()
        VSlog("End of directory set.")

    def searchGlobal(self, sSearchText='', sCat=''):
        """
        Performs a global search across multiple plugins.

        :param sSearchText: The text to search for.
        :param sCat: The category of the search.
        :return: True if the search completes successfully.
        """
        try:
            VSlog("Starting global search.")
            
            # Retrieve search text and category if not provided
            if not sSearchText:
                oInputParameterHandler = cInputParameterHandler()
                sSearchText = oInputParameterHandler.getValue('searchtext')
                sCat = oInputParameterHandler.getValue('sCat')
                VSlog(f"Retrieved search text: {sSearchText} and category: {sCat} from input parameters.")

            sSearchText = sSearchText.replace(':', ' ')
            VSlog(f"Formatted search text: {sSearchText}")

            # Initialize search with the provided text and category
            listPlugins = self._initSearch(sSearchText, sCat)
            VSlog(f"Initialized search with plugins: {listPlugins}")

            if len(listPlugins) == 0:
                VSlog("No plugins available for search.")
                return True

            # Launch search threads for each plugin
            listThread = self._launchSearch(listPlugins, self._pluginSearch, [Quote(sSearchText), True])
            VSlog("Launched search threads.")

            # Wait for all threads to complete
            self._finishSearch(listThread)
            VSlog("Finished search threads.")

            # Display search results in the GUI
            oGui = cGui()
            oGui.addText('globalSearch', self.addons.VSlang(30081) % sSearchText, 'search.png')
            VSlog("Added global search text to GUI.")

            count = 0
            searchResults = cGui().getSearchResult()
            for plugin in listPlugins:
                pluginId = plugin['identifier']
                if pluginId in searchResults.keys() and (len(searchResults[pluginId]) > 0):  # At least one result
                    count += 1
                    VSlog(f"Results found for plugin: {pluginId}")

                    # Display site name
                    oGui.addText(pluginId, '%s. [COLOR olive]%s[/COLOR]' % (count, plugin['name']),
                                 'sites/%s.png' % (pluginId))
                    for result in searchResults[pluginId]:
                        oGui.addFolder(result['guiElement'], result['params'])
                        VSlog(f"Added result to GUI for plugin: {pluginId}")

            if not count:  # No sources returned results
                oGui.addText('globalSearch')  # "Aucune information"
                VSlog("No results found for any plugin.")

            self._progressClose()
            cGui.CONTENT = 'files'
            oGui.setEndOfDirectory()
            VSlog("Set end of directory for GUI.")

        except Exception as error:
            VSlog(f"Error with searchGlobal: {error}")
            traceback.print_exc()
            self._progressForceClose()

        return True

    def playVideo(self, title='', sCat='movie'):
        """
        Initiates video playback by performing a quick search.

        :param title: Title of the video to play.
        :param sCat: Category of the video (default is 'movie').
        :return: Result of the quick search.
        """
        VSlog('Playing video')
        xbmc.executebuiltin("Notification(VStream,Recherche VStream en cours)")
        return self.quickSearch(True, title, sCat)

    def _progressInit(self):
        """
        Initializes the progress bar if autoPlayVideo is not enabled.
        """
        if not self.autoPlayVideo:
            VSlog("Initializing progress bar.")
            self.progress_ = progress().VScreate(large=True)
            VSlog("Progress bar created.")

    def _progressUpdate(self, numberResult):
        """
        Updates the progress bar with the current number of results.

        :param numberResult: The number of results found so far.
        """
        if not self.autoPlayVideo and not self._progressIsCancel():
            VSlog(f"Updating progress bar with {numberResult} results.")
            message = "\n"
            message += (self.addons.VSlang(31209) % numberResult)
            message += "\n"
            message += (self.addons.VSlang(31208) % (", ".join(self.listRemainingPlugins[0:7])))
            if len(self.listRemainingPlugins) > 7:
                message += ", ..."
            self.progress_.VSupdate(self.progress_, self.progressTotal, message, True)
            VSlog("Progress bar updated.")

    def quickSearch(self, autoPlayVideo=False, title='', sCat='movie'):
        """
        Performs a quick search for videos and attempts to auto-play if enabled.

        :param autoPlayVideo: Flag to enable auto-play.
        :param title: Title of the video to search for.
        :param sCat: Category of the video (default is 'movie').
        :return: True if the search completes successfully.
        """
        try:
            VSlog("Starting quick search.")
            self.autoPlayVideo = autoPlayVideo

            searchInfo = self._getSearchInfo(title, sCat)
            VSlog(f"Search info: {searchInfo}")
            listPlugins = self._initSearch(searchInfo['title'], searchInfo['cat'])
            VSlog(f"List of plugins: {listPlugins}")

            if len(listPlugins) == 0:
                VSlog("No plugins available for search.")
                return True

            self.findAndPlay = False
            self.allVideoLink = {}
            self.eventFindOneLink = threading.Event()

            window(10101).setProperty('playVideo', 'true')
            VSlog("Set property 'playVideo' to 'true'.")

            listThread = self._launchSearch(listPlugins, self._quickSearchForPlugin, [searchInfo])
            VSlog("Launched search threads.")

            if autoPlayVideo:
                while len(self.listRemainingPlugins) > 0 and self._continueToSearch():
                    self.eventFindOneLink.wait()
                    self.eventFindOneLink.clear()
                    self._tryToAutoPlaySpecificCriteria(cSearch.MAX_NUMBER_CRITERIA)

                if self._continueToSearch():
                    self._tryToAutoPlay()

            self._finishSearch(listThread)
            window(10101).setProperty('playVideo', 'false')
            VSlog("Set property 'playVideo' to 'false'.")

            self._progressClose()

            if not self.findAndPlay:
                self._displayAllResult(searchInfo)

        except Exception as error:
            VSlog(f"Error with quickSearch: {error}")
            traceback.print_exc()
            self._progressForceClose()

        return True

    def _progressInit(self):
        """
        Initializes the progress bar if autoPlayVideo is not enabled.
        """
        if not self.autoPlayVideo:
            VSlog("Initializing progress bar.")
            # Kodi 17 closes the busy dialog that appears above the progress bar
            try:
                xbmc.executebuiltin('Dialog.Close(busydialog)')
                VSlog("Closed busy dialog.")
            except Exception as e:
                VSlog(f"Failed to close busy dialog: {e}")

            self.progress_ = progress().VScreate(large=True)
            VSlog("Progress bar created.")

    def _progressIsCancel(self):
        """
        Checks if the progress bar has been canceled.
        """
        if not self.autoPlayVideo:
            isCanceled = self.progress_.iscanceled()
            VSlog(f"Progress bar canceled: {isCanceled}")
            return isCanceled
        else:
            VSlog("AutoPlayVideo is enabled, progress bar not checked for cancellation.")
            return False

    def _progressClose(self):
        """
        Closes the progress bar if autoPlayVideo is not enabled.
        """
        if not self.autoPlayVideo:
            VSlog("Closing progress bar.")
            self.progress_.VSclose(self.progress_)
            VSlog("Progress bar closed.")

    def _progressForceClose(self):
        """
        Forces the progress bar to close.
        """
        VSlog("Forcing progress bar to close.")
        progress().VSclose()
        VSlog("Progress bar forced to close.")

    def _monitorAbortRequest(self):
        """
        Checks if an abort request has been made.
        """
        abortRequested = xbmc.Monitor().abortRequested()
        VSlog(f"Abort requested: {abortRequested}")
        return abortRequested

    def _continueToSearch(self):
        """
        Checks if the search process should continue based on various conditions.

        :return: True if the search should continue, False otherwise.
        """
        VSlog("Checking if search should continue")
        
        # Determine if the search should continue
        shouldContinue = not (self.findAndPlay or self._monitorAbortRequest() or self._progressIsCancel())
        
        VSlog(f"Search should {'continue' if shouldContinue else 'stop'}")
        return shouldContinue

    def _getAvailablePlugins(self, searchText, categorie):
        """
        Retrieves the list of available plugins based on the search text and category.

        :param searchText: The text to search for.
        :param categorie: The category of the search.
        :return: A list of available plugins.
        """
        VSlog(f"Retrieving available plugins for search text: {searchText} and category: {categorie}")

        # Initialize the search handler
        oHandler = cRechercheHandler()
        VSlog("Initialized cRechercheHandler")

        # Set the search text and category
        oHandler.setText(searchText)
        VSlog(f"Set search text: {searchText}")
        oHandler.setCat(categorie)
        VSlog(f"Set search category: {categorie}")

        # Retrieve and return the available plugins
        availablePlugins = oHandler.getAvailablePlugins()
        VSlog(f"Available plugins retrieved: {availablePlugins}")

        return availablePlugins

    def _initSearch(self, searchText, searchCat):
        """
        Initializes the search process by retrieving available plugins and setting up progress tracking.

        :param searchText: The text to search for.
        :param searchCat: The category of the search.
        :return: A list of plugins that will be used for the search.
        """
        VSlog(f"Initializing search with text: {searchText} and category: {searchCat}")

        try:
            # Retrieve the list of available plugins based on the search text and category
            listPlugins = self._getAvailablePlugins(searchText, searchCat)
            VSlog(f"Available plugins: {listPlugins}")

            if not listPlugins:
                VSlog("No plugins available for the given search criteria.")
                return []

            # Set the total progress based on the number of plugins
            self.progressTotal = len(listPlugins)
            VSlog(f"Total progress set to: {self.progressTotal}")

            # Initialize the progress bar
            self._progressInit()
            VSlog("Progress bar initialized.")

            # Store the names of the remaining plugins to search
            self.listRemainingPlugins = [plugin['name'] for plugin in listPlugins]
            VSlog(f"Remaining plugins to search: {self.listRemainingPlugins}")

            # Reset the search results in the GUI
            cGui().resetSearchResult()
            VSlog("Search results in GUI reset.")

            return listPlugins

        except Exception as error:
            # Log the error details if an exception occurs
            VSlog(f"Error when search is initiated: {error}")
            traceback.print_exc()
            self._progressForceClose()
            return []

    def _launchSearch(self, listPlugins, targetFunction, argsList):
        """
        Launches search threads for the given list of plugins.

        Args:
            listPlugins (list): A list of plugin dictionaries. Each dictionary should contain plugin-specific details, such as 'name'.
            targetFunction (function): The function to be executed by each thread.
            argsList (list): Additional arguments to be passed to the targetFunction.

        Returns:
            list: A list of thread objects that have been started.
        """
        VSlog("Starting to launch search threads.")
        listThread = []  # Container for threads
        window(10101).setProperty('search', 'true')  # Signal search start in Kodi UI
        VSlog("Set Kodi window property 'search' to 'true'.")

        # Create and start a thread for each plugin
        for plugin in listPlugins:
            VSlog(f"Preparing to launch thread for plugin: {plugin['name']} (ID: {plugin['identifier']})")
            # Prepare thread arguments
            threadArgs = tuple([plugin] + argsList)
            VSlog(f"Thread arguments for plugin {plugin['name']}: {threadArgs}")
            # Create thread
            thread = threading.Thread(target=targetFunction, name=plugin['name'], args=threadArgs)
            thread.start()  # Start thread execution
            VSlog(f"Started thread for plugin: {plugin['name']}")
            listThread.append(thread)  # Add thread to the list

        VSlog("All threads have been launched.")
        return listThread

    def _finishSearch(self, listThread):
        """
        Waits for all threads in the provided list to complete and marks the search as finished.

        Args:
            listThread (list): A list of threads to wait for.
        """
        VSlog("Starting to finish search. Waiting for all threads to complete.")
        
        # Wait for each thread in the list to finish execution
        for thread in listThread:
            VSlog(f"Waiting for thread: {thread.name}")
            thread.join()  # Blocks until the thread completes
            VSlog(f"Thread {thread.name} has completed.")

        # Update the Kodi window property to indicate that the search has concluded
        window(10101).setProperty('search', 'false')
        VSlog("Search has concluded. Updated Kodi window property.")

    def _tryToAutoPlay(self):
        """
        Attempts to auto-play video links, prioritizing those with the highest criteria scores.
        """
        VSlog("Attempting to auto-play video links.")
        
        if len(self.allVideoLink) > 0:  # Check if there are any video links to process
            numberMaxCriteria = max(self.allVideoLink.keys())  # Get the highest criteria score
            VSlog(f"Highest criteria score found: {numberMaxCriteria}")

            # Iterate from the highest score to the lowest score
            for iNumberCriteria in range(numberMaxCriteria, 0, -1):
                VSlog(f"Attempting to auto-play videos with criteria score: {iNumberCriteria}")
                self._tryToAutoPlaySpecificCriteria(iNumberCriteria)  # Attempt to play videos for the current score
        else:
            VSlog("No video links found to auto-play.")

    def _tryToAutoPlaySpecificCriteria(self, numberCriteria):
        """
        Attempts to auto-play video links with a specific criteria score.

        :param numberCriteria: The criteria score of the video links to attempt to play.
        """
        VSlog(f"Attempting to auto-play video links with criteria score: {numberCriteria}")

        if numberCriteria in self.allVideoLink:  # Check if there are links with the given criteria score
            VSlog(f"Found video links with criteria score: {numberCriteria}")

            for searchResult in self.allVideoLink[numberCriteria]:
                VSlog(f"Processing search result: {searchResult}")

                # Check if search should continue and the result hasn't been tested yet
                if self._continueToSearch() and searchResult['params'].getValue('playTest') == 'false':
                    VSlog("Search should continue and result has not been tested yet")

                    # Mark the result as tested
                    searchResult['params'].addParameter('playTest', 'true')
                    VSlog("Marked result as tested")

                    # Attempt to play the video
                    find = self._playHosterGui(
                        'play', 
                        [searchResult['params'], True]
                    )
                    VSlog(f"Attempted to play video, result: {find}")

                    if find:  # If playback is successful
                        self.findAndPlay = True  # Indicate that a video was successfully found and played
                        VSlog("Playback successful, video found and played")
                        return
        else:
            VSlog(f"No video links found with criteria score: {numberCriteria}")

    def _deepSearchLoop(self, searchResult, searchInfo):
        """
        Recursively navigates plugin menus to locate video links based on search criteria.

        :param searchResult: Dictionary representing the current search result.
        :param searchInfo: Dictionary containing search parameters like title, year, etc.
        """
        VSlog(f"Starting deep search loop for search result: {searchResult} with search info: {searchInfo}")

        if self._continueToSearch():  # Check if the search process should continue
            numberOfCriteria = self._getScoreOfThisResult(searchResult, searchInfo)
            VSlog(f"Number of criteria met: {numberOfCriteria}")

            if numberOfCriteria > 0:  # If the result meets minimum criteria
                videoParams = searchResult['params']  # OutputParameter object
                siteId = searchResult['guiElement'].getSiteName()
                functionName = searchResult['guiElement'].getFunction()

                VSlog(f"Processing result from site: {siteId} with function: {functionName}")

                # If the result is from cHosterGui, process as a video link
                if siteId:# == 'cHosterGui':
                    if numberOfCriteria not in self.allVideoLink:
                        self.allVideoLink[numberOfCriteria] = []

                    # Mark this result as not yet tested for playback
                    searchResult['params'].addParameter('playTest', 'false')
                    self.allVideoLink[numberOfCriteria].append(searchResult)
                    VSlog(f"Added result to allVideoLink with criteria: {numberOfCriteria}")

                    # Auto-play video if it matches the maximum number of criteria
                    if self.autoPlayVideo and numberOfCriteria == cSearch.MAX_NUMBER_CRITERIA:
                        VSlog("Auto-play video as it matches the maximum number of criteria")
                        self.eventFindOneLink.set()  # Signal to launch the video

                else:  # Otherwise, it's a plugin menu, navigate deeper
                    videoParams.addParameter('searchSiteId', siteId)  # Retain the original site
                    cGui().emptySearchResult(siteId)  # Clear previous results from this site
                    VSlog(f"Executing plugin search for site: {siteId} with function: {functionName}")
                    self._executePluginForSearch(siteId, functionName, videoParams)  # Execute the search

                    # Retrieve the new search results from the executed function
                    pluginResult = cGui().getSearchResult()
                    VSlog(f"New search results from site: {siteId}: {pluginResult}")

                    for newSearchResult in pluginResult[siteId]:
                        if self._continueToSearch():  # Continue only if allowed
                            # Merge additional parameters into the new result
                            newSearchResult['params'].mergeUnexistingInfos(videoParams)
                            newSearchResult['params'].addParameter('searchSiteId', siteId)
                            VSlog(f"Merged parameters into new search result: {newSearchResult}")

                            # Avoid infinite recursion on the same function
                            if newSearchResult['guiElement'].getSiteName() == siteId and \
                               newSearchResult['guiElement'].getFunction() == functionName:
                                VSlog(f"Will not loop on the same function: {siteId}.{functionName}")
                            else:
                                # Recursively navigate deeper
                                self._deepSearchLoop(newSearchResult, searchInfo)
                        else:
                            VSlog("Search process stopped")
                            break

    def _quickSearchForPlugin(self, plugin, searchInfo):
        """
        Perform a quick search for a given plugin and process its results.

        :param plugin: Dictionary containing plugin information ('identifier', 'name', etc.).
        :param searchInfo: Dictionary containing search information ('title', 'year', etc.).
        """
        VSlog(f"Starting quick search for plugin: {plugin['name']} (ID: {plugin['identifier']})")
        VSlog(f"Search information: {searchInfo}")

        pluginId = plugin['identifier']
        pluginName = plugin['name']

        if self._continueToSearch():  # Check if the search should proceed
            VSlog(f"Initiating plugin search with title: {searchInfo['title']}")
            # Initiate plugin search with the quoted search title
            self._pluginSearch(plugin, Quote(searchInfo['title']))
            searchResults = cGui().getSearchResult()  # Retrieve results from GUI search

            VSlog(f"Search results for plugin {pluginName} (ID: {pluginId}): {searchResults}")

            if pluginId in searchResults and len(searchResults[pluginId]) > 0:  # If there are results for this plugin
                pluginResult = searchResults[pluginId][:]  # Copy results to avoid modifying the original
                VSlog(f"Results found for plugin {pluginName}: {pluginResult}")

                for searchResult in pluginResult:
                    # Add plugin name as a parameter to the result
                    searchResult['params'].addParameter('searchSiteName', pluginName)
                    VSlog(f"Added plugin name to search result parameters: {searchResult['params']}")

                    # Perform deep search loop on the result
                    self._deepSearchLoop(searchResult, searchInfo)

                    # Break if search should stop
                    if not self._continueToSearch():
                        VSlog("Search stopped by user or system.")
                        break
            else:
                VSlog(f"No result for plugin: {pluginId}")  # Log if no results are found for this plugin

        # Remove the plugin from the list of remaining plugins to search
        self.listRemainingPlugins.remove(pluginName)
        VSlog(f"Removed plugin {pluginName} from remaining plugins list.")

        # Update the progress bar or any other progress indicators
        self._progressUpdate(sum(map(len, self.allVideoLink.values())))
        VSlog("Updated progress bar with current search results.")

        # If all plugins have been processed and autoplay is enabled, signal the event
        if len(self.listRemainingPlugins) == 0 and self.autoPlayVideo:
            VSlog("All plugins processed and autoplay is enabled. Signaling event to find one link.")
            self.eventFindOneLink.set()

    def _removeNonLetterCaracter(self, word):
        """
        Removes non-alphanumeric characters from a string and normalizes accented characters.

        :param word: The input string to process.
        :return: A cleaned string with non-alphanumeric characters replaced by spaces 
                 and accented characters normalized.
        """
        VSlog(f"Original word: {word}")

        # Replace non-alphanumeric characters with spaces
        result = re.sub(r'[^a-zA-Z0-9]', ' ', word, flags=re.I)
        VSlog(f"After replacing non-alphanumeric characters: {result}")

        # Normalize accented characters
        result = re.sub(r'[éèêë]', 'e', result, flags=re.I)
        VSlog(f"After normalizing 'éèêë' to 'e': {result}")
        result = re.sub(r'à', 'a', result, flags=re.I)
        VSlog(f"After normalizing 'à' to 'a': {result}")
        result = re.sub(r'ô', 'o', result, flags=re.I)
        VSlog(f"After normalizing 'ô' to 'o': {result}")
        result = re.sub(r'ù', 'u', result, flags=re.I)
        VSlog(f"After normalizing 'ù' to 'u': {result}")
        result = re.sub(r'œ', 'oe', result, flags=re.I)
        VSlog(f"After normalizing 'œ' to 'oe': {result}")

        # Remove extra spaces introduced by replacements
        result = re.sub(r'\s+', ' ', result).strip()
        VSlog(f"After removing extra spaces: {result}")

        return result

    def _convert_category(self, sCat):
        """
        Converts a string category to its corresponding integer value.

        :param sCat: String representation of the category (e.g., "movie", "series").
        :return: Integer value representing the category, or 0 if not found.
        """
        category_mapping = {
            "movie": 1,
            "series": random.choice([2, 4]),  # Randomly choose between 2 (TV Series) and 4 (Mini-Series)
            # Add more categories as needed in the format: "category_name": category_value
        }

        # Normalize input category to lowercase and retrieve mapped value
        category_value = category_mapping.get(sCat.lower(), 0)

        VSlog(f"Converted category '{sCat}' to value: {category_value}")
        return category_value


    def _getSearchInfo(self, title='', sCat="movie"):
        """
        Retrieves search information including title, category, and year.

        :param title: Title of the content to search for (default is empty).
        :param sCat: Category of content ("movie" or "series").
        :return: Dictionary containing search information or error details.
        """
        oInputParameterHandler = cInputParameterHandler()

        # Validate content type
        if sCat not in ["movie", "series"]:
            VSlog('Invalid content type. Expected "movie" or "series".')
            return {"error": "Invalid content type. Use 'movie' or 'series'."}

        # Initialize search text
        sSearchText = title.strip()
        if not sSearchText:
            json_file = FILMS_JSON if sCat == "movie" else SERIES_JSON
            try:
                with open(json_file, "r", encoding="utf-8") as f:
                    suggestions = json.load(f)
                sSearchText = random.choice(suggestions)  # Use a random title if none provided
                VSlog(f'Loaded random title: {sSearchText}')
            except FileNotFoundError:
                error_message = f"File not found: {json_file}"
                VSlog(error_message)
                return {"error": error_message}
            except json.JSONDecodeError:
                error_message = f"Failed to decode JSON from file: {json_file}"
                VSlog(error_message)
                return {"error": error_message}

        # Determine category
        if oInputParameterHandler.exist('cat'):
            searchCat = int(oInputParameterHandler.getValue('cat'))
            VSlog(f'Category retrieved from input parameters: {searchCat}')
        else:
            searchCat = self._convert_category(sCat)
            VSlog(f'Category converted from sCat parameter: {searchCat}')

        # Determine title
        if oInputParameterHandler.exist('title'):
            searchTitle = self._removeNonLetterCaracter(oInputParameterHandler.getValue('title'))
            VSlog(f'Title retrieved from input parameters: {searchTitle}')
        else:
            searchTitle = self._removeNonLetterCaracter(sSearchText)
            VSlog(f'Title processed from input or default: {searchTitle}')

        # Determine year
        if oInputParameterHandler.exist('year'):
            searchYear = str(oInputParameterHandler.getValue('year'))
            VSlog(f'Year retrieved from input parameters: {searchYear}')
        else:
            searchYear = ""
            VSlog('Year not provided; defaulting to empty.')

        # Return search info
        search_info = {'title': searchTitle, 'cat': searchCat, 'year': searchYear}
        VSlog(f'Constructed search info: {search_info}')
        return search_info

    def _isYearCorrect(self, result, searchInfo):
        """
        Checks if the year of the search result matches the search criteria.

        :param result: The search result to check.
        :param searchInfo: The search information containing user preferences.
        :return: 1 if the year does not match, -1 if it matches, 0 if neutral.
        """
        resultYear = result['params'].getValue('sYear')
        searchYear = searchInfo.get('year', '')

        VSlog("Checking year correctness:")
        VSlog(f"Search Year: {searchYear}, Result Year: {resultYear}")

        if resultYear:
            if resultYear != searchYear:
                VSlog(f"Year mismatch: Result Year ({resultYear}) does not match Search Year ({searchYear}).")
                return 1
            else:
                VSlog(f"Year match excluded: Exact match found with year {resultYear}.")
                return -1
        else:
            VSlog("Result year is missing. Defaulting to neutral (1).")
            return 1

    def _isMovieTitleCorrect(self, result, searchInfo):
        """
        Checks if the movie title of the search result matches the search criteria.

        :param result: The search result to check.
        :param searchInfo: The search information containing user preferences.
        :return: 2 if the title matches exactly, 1 if it partially matches, -1 if it does not match, 0 if neutral.
        """
        resultTitle = result['params'].getValue('sMovieTitle')
        VSlog("Checking movie title correctness:")
        VSlog(f"Search title: {searchInfo['title']}, Result title: {resultTitle}")

        if resultTitle:
            if self._checkAllSearchWordInTitle(searchInfo['title'], resultTitle):
                normalizedSearchTitle = searchInfo['title'].lower()
                normalizedResultTitle = self._removeNonLetterCaracter(resultTitle).lower()
                
                VSlog("All search words found in result title. Normalized titles for comparison:")
                VSlog(f"Normalized Search Title: {normalizedSearchTitle}")
                VSlog(f"Normalized Result Title: {normalizedResultTitle}")

                if normalizedSearchTitle == normalizedResultTitle:
                    VSlog("Exact title match found.")
                    return 2
                else:
                    VSlog("Partial title match found.")
                    return 1
            else:
                VSlog(f"Exclude result because not all search words are in the title: {resultTitle}")
                return -1
        else:
            VSlog("Result title is missing. Defaulting to neutral (0).")
            return 0

    def _isLangCorrect(self, result, searchInfo):
        """
        Checks if the language of the search result matches the user's language preferences.

        :param result: The search result to check.
        :param searchInfo: The search information containing user preferences.
        :return: 1 if the language matches, -1 if it doesn't, 0 if neutral.
        """
        resultLang = str(result['params'].getValue('sLang')).lower()
        autoPlayLang = self.addons.getSetting('autoPlayLang')  # 0 = fr, vostfr; 1 = fr; 2 = all

        VSlog("Checking language correctness:")
        VSlog(f"Result language: {resultLang}, AutoPlay language setting: {autoPlayLang}")

        if resultLang and resultLang != 'false':
            if autoPlayLang == '1':
                if 'vf' in resultLang or 'truefrench' in resultLang:
                    VSlog(f"Language match: 'fr' detected in resultLang: {resultLang}")
                    return 1
                elif 'en' in resultLang or 'vostfr' in resultLang:
                    VSlog(f"Exclude result due to 'en' or 'vostfr' in resultLang: {resultLang}")
                    return -1
            elif autoPlayLang == '0':
                if 'vf' in resultLang or 'truefrench' in resultLang or 'vostfr' in resultLang:
                    VSlog(f"Language match: 'vf', 'truefrench', or 'vostfr' detected in resultLang: {resultLang}")
                    return 1
            elif autoPlayLang == '2':
                VSlog(f"Language setting allows all. Accepting resultLang: {resultLang}")
                return 1
        else:
            VSlog("Result language is empty or marked as 'false'. Defaulting to neutral.")

        VSlog("Language correctness check resulted in no match.")
        return 0


    def _isCategorieCorrect(self, result, searchInfo):
        """
        Checks if the category of the search result matches the search criteria.

        :param result: The search result to check.
        :param searchInfo: The search information containing user preferences.
        :return: 1 if the category matches, -1 if it doesn't, 0 if neutral.
        """
        searchCat = searchInfo['cat']
        try:
            resultMeta = int(result['params'].getValue('sMeta'))
        except (ValueError, TypeError):
            VSlog("Error converting result meta value to integer. Defaulting to 0.")
            resultMeta = 0

        VSlog("Checking category correctness:")
        VSlog(f"Search category: {searchCat}, Result meta: {resultMeta}")

        if searchCat >= 0 and resultMeta != 0:
            if searchCat == 1 and resultMeta != 1:
                VSlog(f"Exclude result because it is not a movie (meta: {resultMeta})")
                return -1
            # Currently, series validation is limited
            elif searchCat in [2, 4] and resultMeta not in [2, 5]:
                VSlog(f"Exclude result because it is not a series (meta: {resultMeta})")
                return -1
            else:
                VSlog("Category is correct.")
                return 1

        VSlog("Category is neutral or does not match any exclusion criteria.")
        return 0

    def _getScoreOfThisResult(self, result, searchInfo):
        """
        Calculates the score for a search result based on various criteria.

        :param result: The search result to score.
        :param searchInfo: The search information containing user preferences.
        :return: The total score for the result.
        """
        VSlog("Calculating score for the result:")
        VSlog(f"Search info: {searchInfo}")
        VSlog(f"Result params: {result['params']}")

        yearScore = self._isYearCorrect(result, searchInfo)
        VSlog(f"Year score: {yearScore}")

        titleScore = self._isMovieTitleCorrect(result, searchInfo)
        VSlog(f"Title score: {titleScore}")

        langScore = self._isLangCorrect(result, searchInfo)
        VSlog(f"Language score: {langScore}")

        catScore = self._isCategorieCorrect(result, searchInfo)
        VSlog(f"Category score: {catScore}")

        # Check if any individual score disqualifies the result
        if yearScore < 0:
            VSlog("Year score is negative. Excluding result.")
        if titleScore < 0:
            VSlog("Title score is negative. Excluding result.")
        if langScore < 0:
            VSlog("Language score is negative. Excluding result.")
        if catScore < 0:
            VSlog("Category score is negative. Excluding result.")

        if yearScore < 0 or titleScore < 0 or langScore < 0 or catScore < 0:
            VSlog("Result disqualified due to negative scores.")
            return 0

        totalScore = yearScore + titleScore + langScore + catScore
        if totalScore == 4: #rigged it
            totalScore = 5
        VSlog(f"Total score for this result: {totalScore}")
        return totalScore

    def _checkAllSearchWordInTitle(self, searchTitle, resultTitle):
        """
        Checks if all words in the search title are present in the result title.

        :param searchTitle: The search title to check.
        :param resultTitle: The result title to check against.
        :return: True if all words are present, False otherwise.
        """
        VSlog("Checking if all words in search title are in result title.")
        VSlog(f"Original search title: '{searchTitle}', Result title: '{resultTitle}'")
        
        searchTitle = searchTitle.lower()
        resultTitle = resultTitle.lower()
        
        VSlog(f"Lowercased search title: '{searchTitle}', Lowercased result title: '{resultTitle}'")

        for word in searchTitle.split():
            if word not in resultTitle:
                VSlog(f"Word '{word}' not found in result title.")
                return False
            VSlog(f"Word '{word}' found in result title.")
        
        VSlog("All words in the search title are present in the result title.")
        return True

    def _displayAllResult(self, searchInfo):
        """
        Displays all search results in the GUI.

        :param searchInfo: The search information containing user preferences.
        """
        VSlog("Starting to display all results.")
        
        try:
            # Initialize GUI and display the global search info
            searchGui = cGui()
            allSearchInfo = f"{searchInfo['title']} {searchInfo['year']}"
            VSlog(f"Search info: {allSearchInfo}")
            searchGui.addText('globalSearch', self.addons.VSlang(30081) % allSearchInfo, 'search.png')
            VSlog("Added global search info to the GUI.")

            # Check if there are any video links
            if len(self.allVideoLink) == 0:
                VSlog("No video links found. Displaying 'no information' message.")
                searchGui.addText('globalSearch')  # "Aucune information"
            else:
                # Iterate over results by criteria
                maxCriteria = max(self.allVideoLink.keys(), default=0)
                VSlog(f"Maximum criteria found: {maxCriteria}")
                
                for numCriteria in range(maxCriteria, 0, -1):
                    if numCriteria in self.allVideoLink.keys():
                        VSlog(f"Processing results with {numCriteria} criteria.")
                        for result in self.allVideoLink[numCriteria]:
                            VSlog(f"Displaying result: {result}")
                            self._displayOneResult(searchGui, result)

            # Set content type and end directory
            cGui.CONTENT = 'files'
            searchGui.setEndOfDirectory()
            VSlog("Finished displaying all results. End of directory set.")

        except Exception as e:
            VSlog(f"Error while displaying all results: {e}")
            traceback.print_exc()

        VSlog("Finished execution of _displayAllResult.")

    def _displayOneResult(self, searchGui, result):
        """
        Displays a single search result in the GUI.

        :param searchGui: The GUI object to display the result.
        :param result: The search result to display.
        """
        VSlog("Starting to display a single result.")
        
        try:
            # Retrieve result parameters
            resultParams = result['params']
            VSlog(f"Retrieved result parameters: {resultParams}")

            # Initialize the title with the main title
            title = resultParams.getValue('sTitle')
            if not title:
                VSlog("No title found for the result. Skipping this result.")
                return
            VSlog(f"Initial title: {title}")

            # Add language information to the title
            lang = resultParams.getValue('sLang')
            if lang:
                title += f" ({lang})"
                VSlog(f"Added language to title: {lang}")

            # Add year information to the title
            year = resultParams.getValue('sYear')
            if year:
                title += f" {year}"
                VSlog(f"Added year to title: {year}")

            # Add hoster information to the title
            hoster = resultParams.getValue('sHosterIdentifier')
            if hoster:
                title += f" - [COLOR skyblue]{hoster}[/COLOR]"
                VSlog(f"Added hoster to title: {hoster}")

            # Add quality information to the title
            quality = resultParams.getValue('sQual')
            if quality:
                title += f" [{quality.upper()}]"
                VSlog(f"Added quality to title: {quality}")

            # Add search site name information to the title
            searchSiteName = resultParams.getValue('searchSiteName')
            if searchSiteName:
                title += f" - [COLOR olive]{searchSiteName}[/COLOR]"
                VSlog(f"Added search site name to title: {searchSiteName}")

            # Set the title for the result
            result['guiElement'].setTitle(title)
            VSlog(f"Final title set for the result: {title}")

            # Add the result to the GUI
            searchGui.addFolder(result['guiElement'], result['params'], False)
            VSlog("Added result to the GUI.")

        except Exception as e:
            VSlog(f"Error while displaying result: {e}")
            traceback.print_exc()

        VSlog("Finished displaying a single result.")

    def _pluginSearch(self, plugin, sSearchText, updateProcess=False):
        """
        Performs a search using a specified plugin.

        :param plugin: Dictionary containing plugin information.
        :param sSearchText: The text to search for.
        :param updateProcess: Flag to indicate if the process should be updated.
        """
        VSlog(f"Starting search with plugin: {plugin['name']} (ID: {plugin['identifier']})")
        VSlog(f"Search text: {sSearchText}")
        VSlog(f"Update process flag is {'enabled' if updateProcess else 'disabled'}")

        try:
            # Attempt to import the plugin module
            VSlog(f"Importing module for plugin: {plugin['identifier']}")
            plugins = __import__(f'resources.sites.{plugin["identifier"]}', fromlist=[plugin['identifier']])
            VSlog(f"Successfully imported plugin module: {plugin['identifier']}")

            # Retrieve the search function
            function_name = plugin['search'][1]
            VSlog(f"Retrieving search function: {function_name}")
            function = getattr(plugins, function_name)
            VSlog(f"Search function '{function_name}' successfully retrieved.")

            # Construct the search URL
            sUrl = plugin['search'][0] + str(sSearchText)
            VSlog(f"Constructed search URL: {sUrl}")

            # Execute the search function
            VSlog(f"Executing search function '{function_name}' with URL: {sUrl}")
            function(sUrl)
            VSlog(f"Search function '{function_name}' executed successfully.")

            # Update the process if the flag is enabled
            if updateProcess:
                VSlog(f"Update process is enabled. Removing plugin '{plugin['name']}' from the remaining list.")
                self.listRemainingPlugins.remove(plugin['name'])
                VSlog("Updating progress based on the current search results.")
                self._progressUpdate(sum(map(len, cGui().getSearchResult().values())))

            VSlog(f"Search completed for plugin: {plugin['name']} (ID: {plugin['identifier']})")

        except Exception as e:
            # Log the error details if an exception occurs
            VSlog(f"Error during search with plugin '{plugin['name']}' (ID: {plugin['identifier']}): {e}")
            traceback.print_exc()

    def _executePluginForSearch(self, sSiteName, sFunction, parameters):
        """
        Executes a specified function from a plugin for a given site.

        :param sSiteName: The name of the site.
        :param sFunction: The function to execute.
        :param parameters: The parameters to pass to the function.
        :return: True if the execution is successful, False otherwise.
        """
        VSlog(f"Starting execution of plugin for site: {sSiteName}, function: {sFunction} with parameters: {parameters}")

        try:
            # Import the specified site module dynamically
            VSlog(f"Attempting to import plugin module for site: {sSiteName}")
            plugins = __import__(f'resources.sites.{sSiteName}', fromlist=[sSiteName])
            VSlog(f"Successfully imported module for site: {sSiteName}")

            # Retrieve the specified function from the imported module
            VSlog(f"Retrieving function '{sFunction}' from the module.")
            function = getattr(plugins, sFunction)
            VSlog(f"Function '{sFunction}' successfully retrieved from module '{sSiteName}'.")

            # Execute the function with the provided parameters
            VSlog(f"Executing function '{sFunction}' with parameters: {parameters}")
            function(parameters)
            VSlog(f"Function '{sFunction}' executed successfully.")

            result = True

        except Exception as error:
            # Log the error details if an exception occurs
            VSlog(f"Error while executing plugin for site: {sSiteName}, function: {sFunction}. Error: {error}")
            traceback.print_exc()
            result = False

        VSlog(f"Execution of plugin for site: {sSiteName} complete. Result: {'Success' if result else 'Failure'}")
        return result

    def _playHosterGui(self, sFunction, parameters=None):
        """
        Executes a specified function from the cHosterGui class.

        :param sFunction: The function to execute.
        :param parameters: The parameters to pass to the function (optional).
        :return: The result of the function execution, or None if an error occurs.
        """
        try:
            VSlog(f"Initializing hoster GUI import for function '{sFunction}' with parameters: {parameters}")
            
            # Import the cHosterGui class from the hoster module
            plugins = __import__('resources.lib.gui.hoster', fromlist=['cHosterGui']).cHosterGui()
            VSlog("Successfully imported cHosterGui class.")

            # Retrieve the specified function from the cHosterGui instance
            function = getattr(plugins, sFunction)
            VSlog(f"Successfully retrieved function '{sFunction}' from cHosterGui.")

            # Call the function with or without parameters
            if parameters:
                VSlog(f"Calling function '{sFunction}' with parameters: {parameters}")
                result = function(*parameters)
            else:
                VSlog(f"Calling function '{sFunction}' with no parameters.")
                result = function()

            VSlog(f"Function '{sFunction}' executed successfully. Result: {result}")
            return result

        except Exception as e:
            # Log any exception that occurs during the process
            VSlog(f"Error occurred while executing '{sFunction}' in _playHosterGui: {e}")
            traceback.print_exc()
            return None