Metadata scanning

docker run -it -d \
    --name=torbox-media-center \
    --restart=always \
    --init \
    -v /home/$(whoami)/torbox:/torbox \
    -e TORBOX_API_KEY=<YOUR_API_KEY> \
    -e MOUNT_METHOD=strm \
    -e MOUNT_PATH=/torbox \
    -e ENABLE_METADATA=true \
    anonymoussystems/torbox-media-center:latest

name: torbox-media-center
services:
    torbox-media-center:
        container_name: torbox-media-center
        stdin_open: true
        tty: true
        restart: always
        volumes:
            - /home/$(whoami)/torbox:/torbox
        environment:
            - TORBOX_API_KEY=<YOUR_API_KEY>
            - MOUNT_METHOD=strm
            - MOUNT_PATH=/torbox
            - ENABLE_METADATA=true
        image: anonymoussystems/torbox-media-center:latest

def searchMetadata(query: str, title_data: dict, file_name: str, full_title: str, hash: str, item_name: str):
    base_metadata = {
        "metadata_title": cleanTitle(query),
        "metadata_link": None,
        "metadata_mediatype": "movie",
        "metadata_image": None,
        "metadata_backdrop": None,
        "metadata_years": None,
        "metadata_season": None,
        "metadata_episode": None,
        "metadata_filename": file_name,
        "metadata_rootfoldername": title_data.get("item_name", None),
    }
    if not SCAN_METADATA:
        base_metadata["metadata_rootfoldername"] = item_name
        return base_metadata, False, "Metadata scanning is disabled."
    
    extension = os.path.splitext(file_name)[-1]
    try:
        response = requestWrapper(search_api_http_client, "GET", f"/meta/search/{full_title}", params={"type": "file"})
    except Exception as e:
        logging.error(f"Error searching metadata: {e}")
        return base_metadata, False, f"Error searching metadata: {e}. Searching for {query}, item hash: {hash}"
    
    if response.status_code != 200:
        logging.error(f"Error searching metadata: {response.status_code}. {response.text}")
        return base_metadata, False, f"Error searching metadata. {response.status_code}. Searching for {query}, item hash: {hash}"
    
    try:
        data = response.json().get("data", [])[0]

        title = cleanTitle(data.get("title"))
        base_metadata["metadata_title"] = title
        base_metadata["metadata_years"] = cleanYear(title_data.get("year", None) or data.get("releaseYears", None))

        if data.get("type") == "anime" or data.get("type") == "series":
            series_season_episode = constructSeriesTitle(season=title_data.get("season", None), episode=title_data.get("episode", None))
            file_name = f"{title} {series_season_episode}{extension}"
            base_metadata["metadata_foldername"] = constructSeriesTitle(season=title_data.get("season", 1), folder=True)
            base_metadata["metadata_season"] = title_data.get("season", 1)
            base_metadata["metadata_episode"] = title_data.get("episode")
        elif data.get("type") == "movie":
            file_name = f"{title} ({base_metadata['metadata_years']}){extension}"
        else:
            return base_metadata, False, f"No metadata found. Searching for {query}, item hash: {hash}"
            
        base_metadata["metadata_filename"] = file_name
        base_metadata["metadata_mediatype"] = data.get("type")
        base_metadata["metadata_link"] = data.get("link")
        base_metadata["metadata_image"] = data.get("image")
        base_metadata["metadata_backdrop"] = data.get("backdrop")
        base_metadata["metadata_rootfoldername"] = f"{title} ({base_metadata['metadata_years']})"

        return base_metadata, True, f"Metadata found. Searching for {query}, item hash: {hash}"
    except IndexError:
        return base_metadata, False, f"No metadata found. Searching for {query}, item hash: {hash}"

Title (Year).ext

Show Title (Year)/Season N/Show Title S01E01.ext

Anime Title (Year)/Season N/Anime Title S01E01.ext

if MOUNT_REFRESH_TIME == "instant":
    print("!!! Instant mount refresh time may cause rate limiting issues with the API. Use with caution. !!!")

if SCAN_METADATA and RAW_MODE:
    SCAN_METADATA = False
    print("!!! RAW_MODE IS NOT COMPATIBLE WITH METADATA SCANNING. Disabling metadata scanning. !!!")
else:
    print("!!! Metadata scanning is enabled. This may slow down the processing of files. !!!")

if MOUNT_REFRESH_TIME == "instant" and SCAN_METADATA:
    print("!!! Using instant mount refresh time with metadata scanning may lead to excessive API calls. Falling back to 'fast' refresh time. !!!")
    MOUNT_REFRESH_TIME = MountRefreshTimes.fast.value
else:
    MOUNT_REFRESH_TIME = MountRefreshTimes[MOUNT_REFRESH_TIME].value

# Get the number of CPU cores for parallel processing
max_workers = int(multiprocessing.cpu_count() * 2 - 1)
logging.info(f"Processing files with {max_workers} parallel threads")

# Collect all files to process
files_to_process = []
for item in file_data:
    if not item.get("cached", False):
        continue
    for file in item.get("files", []):
        files_to_process.append((item, file))

# Process files in parallel
with ThreadPoolExecutor(max_workers=max_workers) as executor:
    # Submit all tasks
    future_to_file = {
        executor.submit(process_file, item, file, type): (item, file) 
        for item, file in files_to_process
    }
    
    # Collect results as they complete
    for future in as_completed(future_to_file):
        try:
            data = future.result()
            if data:
                files.append(data)
        except Exception as e:
            item, file = future_to_file[future]
            logging.error(f"Error processing file {file.get('short_name', 'unknown')}: {e}")