create(script): Add tierCreator script for generating group tier custom formats + release group regex patterns

scripts/tierCreator.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+import yaml
+
+
+def load_template(template_path):
+    """Load a YAML template file."""
+    try:
+        with open(template_path, 'r') as f:
+            return f.read()
+    except FileNotFoundError:
+        print(f"Error: Template file not found: {template_path}")
+        sys.exit(1)
+
+
+def create_regex_pattern(group_name, template_dir, output_dir, dry_run=False):
+    """Create a regex pattern file for a release group if it doesn't exist."""
+    output_path = output_dir / f"{group_name}.yml"
+
+    # Skip if pattern already exists
+    if output_path.exists():
+        print(f"Skipping existing regex pattern: {output_path}")
+        return
+
+    print(
+        f"{'Would create' if dry_run else 'Creating'} regex pattern: {output_path}"
+    )
+
+    # Load and fill template
+    template = load_template(template_dir / "releaseGroup.yml")
+    pattern = template.replace("<name>", group_name)
+
+    # Create output directory if it doesn't exist
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Write pattern file if not dry run
+    if not dry_run:
+        with open(output_path, 'w') as f:
+            f.write(pattern)
+
+
+def create_tier_format(tier,
+                       resolution,
+                       type_name,
+                       groups,
+                       template_dir,
+                       output_dir,
+                       dry_run=False):
+    """Create a custom format file for a specific tier."""
+    template = load_template(template_dir / "groupTier.yml")
+
+    # Create release group pattern string
+    release_groups = [
+        group["name"] for group in groups if group["tier"] == tier
+    ]
+    if not release_groups:
+        return
+
+    release_group_pattern = '|'.join(f"(?:{name})" for name in release_groups)
+
+    # Fill in template
+    format_content = (template.replace("<resolution>", resolution).replace(
+        "<type>",
+        type_name).replace("<level>",
+                           str(tier)).replace("<release_group>",
+                                              release_group_pattern))
+
+    # Create output directory if it doesn't exist
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Write custom format file
+    output_path = output_dir / f"{resolution} {type_name} Tier {tier}.yml"
+    print(
+        f"{'Would create' if dry_run else 'Creating'} custom format: {output_path} (includes {len(release_groups)} groups)"
+    )
+
+    if not dry_run:
+        with open(output_path, 'w') as f:
+            f.write(format_content)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Create Radarr custom formats for release group tiers')
+    parser.add_argument('json_file',
+                        help='Input JSON file containing tier data')
+    parser.add_argument('--resolution',
+                        choices=['SD', '720p', '1080p', '2160p'],
+                        required=True,
+                        help='Resolution for custom formats')
+    parser.add_argument('--type',
+                        choices=['Quality', 'Balanced'],
+                        required=True,
+                        help='Type of custom format')
+    parser.add_argument(
+        '--dry-run',
+        action='store_true',
+        help='Show what would be done without making any changes')
+
+    args = parser.parse_args()
+
+    # Setup paths
+    script_dir = Path(__file__).parent
+    template_dir = script_dir.parent / "templates"
+    regex_dir = script_dir.parent / "regex_patterns"
+    format_dir = script_dir.parent / "custom_formats"
+
+    # Load and parse input JSON
+    try:
+        with open(args.json_file, 'r') as f:
+            data = json.load(f)
+    except FileNotFoundError:
+        print(f"Error: Input JSON file not found: {args.json_file}")
+        sys.exit(1)
+    except json.JSONDecodeError:
+        print(f"Error: Invalid JSON file: {args.json_file}")
+        sys.exit(1)
+
+    # Print summary of what we found
+    print(f"\nAnalyzing input file: {args.json_file}")
+    print(
+        f"Found {len(data['tiered_groups'])} release groups across {len(set(group['tier'] for group in data['tiered_groups']))} tiers"
+    )
+
+    if args.dry_run:
+        print("\nDRY RUN - No files will be created or modified\n")
+
+    # Create regex patterns for all groups
+    print("\nProcessing regex patterns:")
+    for group in data["tiered_groups"]:
+        create_regex_pattern(group["name"], template_dir, regex_dir,
+                             args.dry_run)
+
+    # Create tier formats
+    print("\nProcessing custom formats:")
+    unique_tiers = sorted(set(group["tier"]
+                              for group in data["tiered_groups"]))
+    for tier in unique_tiers:
+        create_tier_format(tier, args.resolution, args.type,
+                           data["tiered_groups"], template_dir, format_dir,
+                           args.dry_run)
+
+    print(
+        f"Successfully created custom formats for {args.resolution} {args.type}"
+    )
+
+
+if __name__ == "__main__":
+    main()

templates/groupTier.yml

@@ -0,0 +1,21 @@
+name: <resolution> <type> Tier <level>
+description: Matches release groups who fall under 1080p <type> Tier <level>
+tags:
+  - Release Group
+conditions:
+  - name: Not WEB-DL
+    negate: true
+    required: true
+    source: web_dl
+    type: source
+  - name: <resolution>
+    negate: false
+    required: true
+    resolution: <resolution>
+    type: resolution
+  - name: <release_group>
+    negate: false
+    pattern: <release_group>
+    required: false
+    type: release_group
+tests:

templates/releaseGroup.yml

@@ -0,0 +1,6 @@
+name: <name>
+pattern: (?<=^|[\s.-])<name>\b
+description: ""
+tags:
+  - Release Group
+tests: