更改视频尺寸的定义方式

pixelle_video/utils/template_util.py

@@ -0,0 +1,207 @@
+"""
+Template utility functions for size parsing and template management
+"""
+
+import os
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+
+def parse_template_size(template_path: str) -> Tuple[int, int]:
+    """
+    Parse video size from template path
+    
+    Args:
+        template_path: Template path like "templates/1080x1920/default.html"
+                      or "1080x1920/default.html"
+    
+    Returns:
+        Tuple of (width, height) in pixels
+    
+    Raises:
+        ValueError: If template path format is invalid
+    
+    Examples:
+        >>> parse_template_size("templates/1080x1920/default.html")
+        (1080, 1920)
+        >>> parse_template_size("1920x1080/modern.html")
+        (1920, 1080)
+    """
+    path = Path(template_path)
+    
+    # Get parent directory name (should be like "1080x1920")
+    dir_name = path.parent.name
+    
+    # Special case: if parent is "templates", go up one more level
+    if dir_name == "templates":
+        # This shouldn't happen in new structure, but handle it
+        raise ValueError(
+            f"Invalid template path format: {template_path}. "
+            f"Expected format: 'WIDTHxHEIGHT/template.html' or 'templates/WIDTHxHEIGHT/template.html'"
+        )
+    
+    # Parse size from directory name
+    if 'x' not in dir_name:
+        raise ValueError(
+            f"Invalid size format in path: {template_path}. "
+            f"Directory name should be 'WIDTHxHEIGHT' (e.g., '1080x1920')"
+        )
+    
+    try:
+        width_str, height_str = dir_name.split('x')
+        width = int(width_str)
+        height = int(height_str)
+        
+        # Sanity check
+        if width < 100 or height < 100 or width > 10000 or height > 10000:
+            raise ValueError(f"Invalid size dimensions: {width}x{height}")
+        
+        return (width, height)
+    except ValueError as e:
+        raise ValueError(
+            f"Failed to parse size from path: {template_path}. "
+            f"Expected format: 'WIDTHxHEIGHT/template.html' (e.g., '1080x1920/default.html'). "
+            f"Error: {e}"
+        )
+
+
+def list_available_sizes() -> List[str]:
+    """
+    List all available video sizes
+    
+    Returns:
+        List of size strings like ["1080x1920", "1920x1080", "1080x1080"]
+    
+    Examples:
+        >>> list_available_sizes()
+        ['1080x1920', '1920x1080', '1080x1080']
+    """
+    templates_dir = Path("templates")
+    
+    if not templates_dir.exists():
+        return []
+    
+    sizes = []
+    for item in templates_dir.iterdir():
+        if item.is_dir() and 'x' in item.name:
+            # Validate it's a proper size format
+            try:
+                width, height = item.name.split('x')
+                int(width)
+                int(height)
+                sizes.append(item.name)
+            except (ValueError, AttributeError):
+                # Skip invalid directories
+                continue
+    
+    return sorted(sizes)
+
+
+def list_templates_for_size(size: str) -> List[str]:
+    """
+    List all templates available for a given size
+    
+    Args:
+        size: Size string like "1080x1920"
+    
+    Returns:
+        List of template filenames (without path) like ["default.html", "modern.html"]
+    
+    Examples:
+        >>> list_templates_for_size("1080x1920")
+        ['cartoon.html', 'default.html', 'elegant.html', 'modern.html', ...]
+    """
+    size_dir = Path("templates") / size
+    
+    if not size_dir.exists() or not size_dir.is_dir():
+        return []
+    
+    templates = []
+    for item in size_dir.iterdir():
+        if item.is_file() and item.suffix == '.html':
+            templates.append(item.name)
+    
+    return sorted(templates)
+
+
+def get_template_full_path(size: str, template_name: str) -> str:
+    """
+    Get full template path from size and template name
+    
+    Args:
+        size: Size string like "1080x1920"
+        template_name: Template filename like "default.html"
+    
+    Returns:
+        Full path like "templates/1080x1920/default.html"
+    
+    Raises:
+        FileNotFoundError: If template file doesn't exist
+    
+    Examples:
+        >>> get_template_full_path("1080x1920", "default.html")
+        'templates/1080x1920/default.html'
+    """
+    template_path = Path("templates") / size / template_name
+    
+    if not template_path.exists():
+        available_templates = list_templates_for_size(size)
+        raise FileNotFoundError(
+            f"Template not found: {template_path}\n"
+            f"Available templates for size {size}: {available_templates}"
+        )
+    
+    return str(template_path)
+
+
+def resolve_template_path(template_input: Optional[str]) -> str:
+    """
+    Resolve template input to full path with validation
+    
+    Args:
+        template_input: Can be:
+            - None: Use default "1080x1920/default.html"
+            - "template.html": Use default size + this template
+            - "1080x1920/template.html": Full relative path
+            - "templates/1080x1920/template.html": Absolute-ish path
+    
+    Returns:
+        Resolved full path like "templates/1080x1920/default.html"
+    
+    Raises:
+        FileNotFoundError: If template doesn't exist
+    
+    Examples:
+        >>> resolve_template_path(None)
+        'templates/1080x1920/default.html'
+        >>> resolve_template_path("modern.html")
+        'templates/1080x1920/modern.html'
+        >>> resolve_template_path("1920x1080/default.html")
+        'templates/1920x1080/default.html'
+    """
+    # Default case
+    if template_input is None:
+        template_input = "1080x1920/default.html"
+    
+    # If already starts with "templates/", use as-is
+    if template_input.startswith("templates/"):
+        template_path = Path(template_input)
+    # If contains size directory (e.g., "1080x1920/default.html")
+    elif '/' in template_input and 'x' in template_input.split('/')[0]:
+        template_path = Path("templates") / template_input
+    # Just template name (e.g., "default.html")
+    else:
+        # Use default size
+        template_path = Path("templates") / "1080x1920" / template_input
+    
+    # Validate existence
+    if not template_path.exists():
+        available_sizes = list_available_sizes()
+        raise FileNotFoundError(
+            f"Template not found: {template_path}\n"
+            f"Available sizes: {available_sizes}\n"
+            f"Hint: Use format 'SIZExSIZE/template.html' (e.g., '1080x1920/default.html')"
+        )
+    
+    return str(template_path)
+