Wrong category

[boogertwilliams]

I just got it setup and working with Jellyfin. I only added two test items. One movie and one show, however, the show episodes all got placed in Movies category.

How can this be avoided?

I tried simply moving the folder but it reset to the original after a few minutes.

[ChrolloKyber]

same for me

[weldingwit]

Same here

[ChrolloKyber]

@weldingwit @boogertwilliams I added ENABLE_METADATA=true in my environment variables, it fixed this issue but it gives some false info about the media, wrong names etc. But the classification is completely fine

[ajitid]

Turning ENABLE_METADATA results in 429 error. A much better way I found is to just point your clanker to zurg codebase and ask it to implement the same segregation logic in this media center code. This works for me fairly well, and because it is a local heuristic segregation it doesn't hammer the TorBox APIs either. Not sure why the TorBox dev team didn't provide an option to a local-only segregation.

[ChrolloKyber]

Turning ENABLE_METADATA results in 429 error. A much better way I found is to just point your clanker to zurg codebase and ask it to implement the same segregation logic in this media center code.

Yup started facing this just 2 days ago, asked the clanker to make a script to do exactly this, here's the code if anyone wants to try it out

import os
import shutil
import re


def normalize_name(name):
    """Remove leading/trailing tags like [bitsearch.to] or [QxR]"""
    name = re.sub(r"^\[.*?\]\s*", "", name)
    name = re.sub(r"\s*\[.*?\]$", "", name)
    return name.strip()


def parse_series_info(name):
    """Extract series name and season number from folder name"""
    clean_name = normalize_name(name)

    if re.search(
        r"(Season\s*\d+\s*-\s*\d+|[Ss]\d+\s*-\s*[Ss]\d+)", clean_name, re.IGNORECASE
    ):
        return None, None

    match = re.search(r"([. ]+)([Ss](\d+)|Season\s*(\d+))", clean_name, re.IGNORECASE)
    if match:
        start_index = match.start()
        series_name = clean_name[:start_index].replace(".", " ").strip()

        s_num = match.group(3) or match.group(4)
        if s_num:
            season_num = f"S{int(s_num):02d}"
            return series_name, season_num

    return None, None


def is_likely_series(name, contents):
    """Check if a folder or its contents suggest it's a TV series"""
    series_pattern = re.compile(
        r"([. ]+)([Ss](\d+)|Season\s*(\d+)|[Ss]\d+E\d+)", re.IGNORECASE
    )

    if series_pattern.search(name):
        return True

    for item in contents:
        if series_pattern.search(item):
            return True

    return False


def organize_movies_to_series(movies_dir, series_dir):
    """Move directories from movies to series if they look like TV shows"""
    if not os.path.exists(movies_dir):
        print(f"Movies directory not found at {movies_dir}")
        return

    for item in os.listdir(movies_dir):
        item_path = os.path.join(movies_dir, item)
        if os.path.isdir(item_path):
            try:
                contents = os.listdir(item_path)
                # Refined logic: Move if it matches a series pattern
                if is_likely_series(item, contents):
                    target_path = os.path.join(series_dir, item)
                    print(f"Moving series '{item}' to series directory...")
                    shutil.move(item_path, target_path)
            except Exception as e:
                print(f"Error moving {item}: {e}")


def organize_series_folders(series_dir):
    """Group seasonal folders into parent series folders"""
    if not os.path.exists(series_dir):
        print(f"Series directory not found at {series_dir}")
        return

    series_map = {}
    for item in os.listdir(series_dir):
        item_path = os.path.join(series_dir, item)
        if not os.path.isdir(item_path):
            continue

        series_name, season_num = parse_series_info(item)
        if series_name and season_num:
            if series_name not in series_map:
                series_map[series_name] = []
            series_map[series_name].append((item_path, season_num))

    for series_name, seasons in series_map.items():
        if len(seasons) > 1:
            series_path = os.path.join(series_dir, series_name)
            if not os.path.exists(series_path):
                os.makedirs(series_path)

            for original_path, season_num in seasons:
                target_season_path = os.path.join(series_path, season_num)
                if not os.path.exists(target_season_path):
                    print(
                        f"Organizing '{os.path.basename(original_path)}' -> '{series_name}/{season_num}'"
                    )
                    shutil.move(original_path, target_season_path)


def cleanup_misplaced_movies(series_dir, movies_dir):
    """Move back folders that were incorrectly moved to series"""
    if not os.path.exists(series_dir):
        return

    for item in os.listdir(series_dir):
        item_path = os.path.join(series_dir, item)
        if os.path.isdir(item_path):
            contents = os.listdir(item_path)
            # Skip if it's already a parent folder containing Sxx subfolders
            if all(re.match(r"S\d+", c) for c in contents) and len(contents) > 0:
                continue

            # If it's a known movie that was misplaced, move it back
            if (
                "The Postman (1994)" in item
                or "Green Book (2018)" in item
                or "Star Wars - Episode II" in item
            ):
                target_path = os.path.join(movies_dir, item)
                print(f"Moving misplaced movie '{item}' back to movies...")
                shutil.move(item_path, target_path)


def main():
    # Base directory is now hardcoded to torbox relative to the specified root
    base_dir = "/home/rishay/Codes/Homelab/Jellyfin/torbox"
    movies_dir = os.path.join(base_dir, "movies")
    series_dir = os.path.join(base_dir, "series")

    if not os.path.exists(series_dir):
        os.makedirs(series_dir)

    print("--- Phase 0: Cleaning up misplaced movies ---")
    cleanup_misplaced_movies(series_dir, movies_dir)

    print("\n--- Phase 1: Moving series folders from movies to series ---")
    organize_movies_to_series(movies_dir, series_dir)

    print("\n--- Phase 2: Organizing seasonal folders into series parents ---")
    organize_series_folders(series_dir)


if __name__ == "__main__":
    main()

It can create a parent directory for multi season series and make sure movies with featurettes don't get classified as series