155 lines
4.9 KiB
Python
155 lines
4.9 KiB
Python
#!/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()
|