fix(tags): 🐛 Fix formatting issues

* Implemented `_load_vaults` function to load and validate vaults by name.
* Improved `_copy_service_data` to handle key copying with better logging and error handling.
* Updated `copy` command to utilize the new vault loading function and streamline the process.
* Enhanced key insertion logic in MySQL and SQLite vaults to avoid inserting existing keys.

CHANGELOG.md

@@ -5,27 +5,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
-
-### Added
-
-- **Custom Output Templates**: Flexible filename customization system
-  - New `output_template` configuration in unshackle.yaml for movies, series, and songs
-  - Support for conditional variables using `?` suffix (e.g., `{year?}`, `{hdr?}`)
-  - Comprehensive template variables for title, quality, audio, video, and metadata
-  - Multiple naming styles: Scene-style (dot-separated), Plex-friendly (space-separated), minimal, custom
-  - Automatic template validation and enhanced error handling
-  - **Full backward compatibility**: Old `scene_naming` option still works and automatically converts to equivalent templates
-  - Folder naming now follows series template patterns (excluding episode-specific variables)
-  - Deprecation warnings guide users to migrate from `scene_naming` to `output_template`
-
-### Changed
-
-- **Filename Generation**: Updated all title classes (Movie, Episode, Song) to use new template system
-  - Enhanced context building for template variable substitution
-  - Improved separator handling based on template style detection
-  - Better handling of conditional content like HDR, Atmos, and multi-language audio
-
 ## [1.4.4] - 2025-09-02
 
 ### Added
@@ -47,7 +26,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
-- **Matroska Tag Compliance**: Enhanced media container compatibility
+- **Matroska Tag Compliance**: Enhanced media container compatibility  
   - Fixed Matroska tag compliance with official specification
 - **Application Branding**: Cleaned up version display
   - Removed old devine version reference from banner to avoid developer confusion

unshackle/commands/kv.py

@@ -12,84 +12,113 @@ from unshackle.core.vault import Vault
 from unshackle.core.vaults import Vaults
 
 
+def _load_vaults(vault_names: list[str]) -> Vaults:
+    """Load and validate vaults by name."""
+    vaults = Vaults()
+    for vault_name in vault_names:
+        vault_config = next((x for x in config.key_vaults if x["name"] == vault_name), None)
+        if not vault_config:
+            raise click.ClickException(f"Vault ({vault_name}) is not defined in the config.")
+
+        vault_type = vault_config["type"]
+        vault_args = vault_config.copy()
+        del vault_args["type"]
+
+        if not vaults.load(vault_type, **vault_args):
+            raise click.ClickException(f"Failed to load vault ({vault_name}).")
+
+    return vaults
+
+
+def _process_service_keys(from_vault: Vault, service: str, log: logging.Logger) -> dict[str, str]:
+    """Get and validate keys from a vault for a specific service."""
+    content_keys = list(from_vault.get_keys(service))
+
+    bad_keys = {kid: key for kid, key in content_keys if not key or key.count("0") == len(key)}
+    for kid, key in bad_keys.items():
+        log.warning(f"Skipping NULL key: {kid}:{key}")
+
+    return {kid: key for kid, key in content_keys if kid not in bad_keys}
+
+
+def _copy_service_data(to_vault: Vault, from_vault: Vault, service: str, log: logging.Logger) -> int:
+    """Copy data for a single service between vaults."""
+    content_keys = _process_service_keys(from_vault, service, log)
+    total_count = len(content_keys)
+
+    if total_count == 0:
+        log.info(f"{service}: No keys found in {from_vault}")
+        return 0
+
+    try:
+        added = to_vault.add_keys(service, content_keys)
+    except PermissionError:
+        log.warning(f"{service}: No permission to create table in {to_vault}, skipped")
+        return 0
+
+    existed = total_count - added
+
+    if added > 0 and existed > 0:
+        log.info(f"{service}: {added} added, {existed} skipped ({total_count} total)")
+    elif added > 0:
+        log.info(f"{service}: {added} added ({total_count} total)")
+    else:
+        log.info(f"{service}: {existed} skipped (all existed)")
+
+    return added
+
+
 @click.group(short_help="Manage and configure Key Vaults.", context_settings=context_settings)
 def kv() -> None:
     """Manage and configure Key Vaults."""
 
 
 @kv.command()
-@click.argument("to_vault", type=str)
+@click.argument("to_vault_name", type=str)
-@click.argument("from_vaults", nargs=-1, type=click.UNPROCESSED)
+@click.argument("from_vault_names", nargs=-1, type=click.UNPROCESSED)
 @click.option("-s", "--service", type=str, default=None, help="Only copy data to and from a specific service.")
-def copy(to_vault: str, from_vaults: list[str], service: Optional[str] = None) -> None:
+def copy(to_vault_name: str, from_vault_names: list[str], service: Optional[str] = None) -> None:
     """
     Copy data from multiple Key Vaults into a single Key Vault.
     Rows with matching KIDs are skipped unless there's no KEY set.
     Existing data is not deleted or altered.
 
-    The `to_vault` argument is the key vault you wish to copy data to.
+    The `to_vault_name` argument is the key vault you wish to copy data to.
     It should be the name of a Key Vault defined in the config.
 
-    The `from_vaults` argument is the key vault(s) you wish to take
+    The `from_vault_names` argument is the key vault(s) you wish to take
     data from. You may supply multiple key vaults.
     """
-    if not from_vaults:
+    if not from_vault_names:
         raise click.ClickException("No Vaults were specified to copy data from.")
 
     log = logging.getLogger("kv")
 
-    vaults = Vaults()
+    all_vault_names = [to_vault_name] + list(from_vault_names)
-    for vault_name in [to_vault] + list(from_vaults):
+    vaults = _load_vaults(all_vault_names)
-        vault = next((x for x in config.key_vaults if x["name"] == vault_name), None)
-        if not vault:
-            raise click.ClickException(f"Vault ({vault_name}) is not defined in the config.")
-        vault_type = vault["type"]
-        vault_args = vault.copy()
-        del vault_args["type"]
-        if not vaults.load(vault_type, **vault_args):
-            raise click.ClickException(f"Failed to load vault ({vault_name}).")
 
-    to_vault: Vault = vaults.vaults[0]
+    to_vault = vaults.vaults[0]
-    from_vaults: list[Vault] = vaults.vaults[1:]
+    from_vaults = vaults.vaults[1:]
+
+    vault_names = ", ".join([v.name for v in from_vaults])
+    log.info(f"Copying data from {vault_names} → {to_vault.name}")
 
-    log.info(f"Copying data from {', '.join([x.name for x in from_vaults])}, into {to_vault.name}")
     if service:
         service = Services.get_tag(service)
-        log.info(f"Only copying data for service {service}")
+        log.info(f"Filtering by service: {service}")
 
     total_added = 0
     for from_vault in from_vaults:
-        if service:
+        services_to_copy = [service] if service else from_vault.get_services()
-            services = [service]
-        else:
-            services = from_vault.get_services()
-
-        for service_ in services:
-            log.info(f"Getting data from {from_vault} for {service_}")
-            content_keys = list(from_vault.get_keys(service_))  # important as it's a generator we iterate twice
-
-            bad_keys = {kid: key for kid, key in content_keys if not key or key.count("0") == len(key)}
-
-            for kid, key in bad_keys.items():
-                log.warning(f"Cannot add a NULL Content Key to a Vault, skipping: {kid}:{key}")
-
-            content_keys = {kid: key for kid, key in content_keys if kid not in bad_keys}
-
-            total_count = len(content_keys)
-            log.info(f"Adding {total_count} Content Keys to {to_vault} for {service_}")
-
-            try:
-                added = to_vault.add_keys(service_, content_keys)
-            except PermissionError:
-                log.warning(f" - No permission to create table ({service_}) in {to_vault}, skipping...")
-                continue
 
+        for service_tag in services_to_copy:
+            added = _copy_service_data(to_vault, from_vault, service_tag, log)
             total_added += added
-            existed = total_count - added
 
-            log.info(f"{to_vault} ({service_}): {added} newly added, {existed} already existed (skipped)")
+    if total_added > 0:
-
+        log.info(f"Successfully added {total_added} new keys to {to_vault}")
-    log.info(f"{to_vault}: {total_added} total newly added")
+    else:
+        log.info("Copy completed - no new keys to add")
 
 
 @kv.command()
@@ -106,9 +135,9 @@ def sync(ctx: click.Context, vaults: list[str], service: Optional[str] = None) -
     if not len(vaults) > 1:
         raise click.ClickException("You must provide more than one Vault to sync.")
 
-    ctx.invoke(copy, to_vault=vaults[0], from_vaults=vaults[1:], service=service)
+    ctx.invoke(copy, to_vault_name=vaults[0], from_vault_names=vaults[1:], service=service)
     for i in range(1, len(vaults)):
-        ctx.invoke(copy, to_vault=vaults[i], from_vaults=[vaults[i - 1]], service=service)
+        ctx.invoke(copy, to_vault_name=vaults[i], from_vault_names=[vaults[i - 1]], service=service)
 
 
 @kv.command()
@@ -135,15 +164,7 @@ def add(file: Path, service: str, vaults: list[str]) -> None:
     log = logging.getLogger("kv")
     service = Services.get_tag(service)
 
-    vaults_ = Vaults()
+    vaults_ = _load_vaults(list(vaults))
-    for vault_name in vaults:
-        vault = next((x for x in config.key_vaults if x["name"] == vault_name), None)
-        if not vault:
-            raise click.ClickException(f"Vault ({vault_name}) is not defined in the config.")
-        vault_type = vault["type"]
-        vault_args = vault.copy()
-        del vault_args["type"]
-        vaults_.load(vault_type, **vault_args)
 
     data = file.read_text(encoding="utf8")
     kid_keys: dict[str, str] = {}
@@ -173,15 +194,7 @@ def prepare(vaults: list[str]) -> None:
     """Create Service Tables on Vaults if not yet created."""
     log = logging.getLogger("kv")
 
-    vaults_ = Vaults()
+    vaults_ = _load_vaults(vaults)
-    for vault_name in vaults:
-        vault = next((x for x in config.key_vaults if x["name"] == vault_name), None)
-        if not vault:
-            raise click.ClickException(f"Vault ({vault_name}) is not defined in the config.")
-        vault_type = vault["type"]
-        vault_args = vault.copy()
-        del vault_args["type"]
-        vaults_.load(vault_type, **vault_args)
 
     for vault in vaults_:
         if hasattr(vault, "has_table") and hasattr(vault, "create_table"):

unshackle/core/config.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import re
-import warnings
 from pathlib import Path
 from typing import Any, Optional
 
@@ -92,116 +90,13 @@ class Config:
         self.tmdb_api_key: str = kwargs.get("tmdb_api_key") or ""
         self.update_checks: bool = kwargs.get("update_checks", True)
         self.update_check_interval: int = kwargs.get("update_check_interval", 24)
-
+        self.scene_naming: bool = kwargs.get("scene_naming", True)
-        # Handle backward compatibility for scene_naming option
+        self.series_year: bool = kwargs.get("series_year", True)
-        self.scene_naming: Optional[bool] = kwargs.get("scene_naming")
-        self.output_template: dict = kwargs.get("output_template") or {}
-
-        # Apply scene_naming compatibility if no output_template is defined
-        self._apply_scene_naming_compatibility()
-
-        # Validate output templates
-        self._validate_output_templates()
 
         self.title_cache_time: int = kwargs.get("title_cache_time", 1800)  # 30 minutes default
         self.title_cache_max_retention: int = kwargs.get("title_cache_max_retention", 86400)  # 24 hours default
         self.title_cache_enabled: bool = kwargs.get("title_cache_enabled", True)
 
-    def _apply_scene_naming_compatibility(self) -> None:
-        """Apply backward compatibility for the old scene_naming option."""
-        if self.scene_naming is not None:
-            # Only apply if no output_template is already defined
-            if not self.output_template.get("movies") and not self.output_template.get("series"):
-                if self.scene_naming:
-                    # scene_naming: true = scene-style templates
-                    self.output_template.update(
-                        {
-                            "movies": "{title}.{year}.{quality}.{source}.WEB-DL.{dual?}.{multi?}.{audio_full}.{atmos?}.{hdr?}.{hfr?}.{video}-{tag}",
-                            "series": "{title}.{year?}.{season_episode}.{episode_name?}.{quality}.{source}.WEB-DL.{dual?}.{multi?}.{audio_full}.{atmos?}.{hdr?}.{hfr?}.{video}-{tag}",
-                            "songs": "{track_number}.{title}.{source?}.WEB-DL.{audio_full}.{atmos?}-{tag}",
-                        }
-                    )
-                else:
-                    # scene_naming: false = Plex-friendly templates
-                    self.output_template.update(
-                        {
-                            "movies": "{title} ({year}) {quality}",
-                            "series": "{title} {season_episode} {episode_name?}",
-                            "songs": "{track_number}. {title}",
-                        }
-                    )
-
-                # Warn about deprecated option
-                warnings.warn(
-                    "The 'scene_naming' option is deprecated. Please use 'output_template' instead. "
-                    "Your current setting has been converted to equivalent templates.",
-                    DeprecationWarning,
-                    stacklevel=2,
-                )
-
-    def _validate_output_templates(self) -> None:
-        """Validate output template configurations and warn about potential issues."""
-        if not self.output_template:
-            return
-
-        # Known template variables for validation
-        valid_variables = {
-            # Basic variables
-            "title",
-            "year",
-            "season",
-            "episode",
-            "season_episode",
-            "episode_name",
-            "quality",
-            "resolution",
-            "source",
-            "tag",
-            "track_number",
-            "artist",
-            "album",
-            "disc",
-            # Audio variables
-            "audio",
-            "audio_channels",
-            "audio_full",
-            "atmos",
-            "dual",
-            "multi",
-            # Video variables
-            "video",
-            "hdr",
-            "hfr",
-        }
-
-        # Filesystem-unsafe characters that could cause issues
-        unsafe_chars = r'[<>:"/\\|?*]'
-
-        for template_type, template_str in self.output_template.items():
-            if not isinstance(template_str, str):
-                warnings.warn(f"Template '{template_type}' must be a string, got {type(template_str).__name__}")
-                continue
-
-            # Extract variables from template
-            variables = re.findall(r"\{([^}]+)\}", template_str)
-
-            # Check for unknown variables
-            for var in variables:
-                # Remove conditional suffix if present
-                var_clean = var.rstrip("?")
-                if var_clean not in valid_variables:
-                    warnings.warn(f"Unknown template variable '{var}' in {template_type} template")
-
-            # Check for filesystem-unsafe characters outside of variables
-            # Replace variables with safe placeholders for testing
-            test_template = re.sub(r"\{[^}]+\}", "TEST", template_str)
-            if re.search(unsafe_chars, test_template):
-                warnings.warn(f"Template '{template_type}' may contain filesystem-unsafe characters")
-
-            # Check for empty template
-            if not template_str.strip():
-                warnings.warn(f"Template '{template_type}' is empty")
-
     @classmethod
     def from_yaml(cls, path: Path) -> Config:
         if not path.exists():

unshackle/core/titles/episode.py

@@ -12,7 +12,6 @@ from unshackle.core.config import config
 from unshackle.core.constants import AUDIO_CODEC_MAP, DYNAMIC_RANGE_MAP, VIDEO_CODEC_MAP
 from unshackle.core.titles.title import Title
 from unshackle.core.utilities import sanitize_filename
-from unshackle.core.utils.template_formatter import TemplateFormatter
 
 
 class Episode(Title):
@@ -79,154 +78,116 @@ class Episode(Title):
         self.year = year
         self.description = description
 
-    def _build_template_context(self, media_info: MediaInfo, show_service: bool = True) -> dict:
-        """Build template context dictionary from MediaInfo."""
-        primary_video_track = next(iter(media_info.video_tracks), None)
-        primary_audio_track = next(iter(media_info.audio_tracks), None)
-        unique_audio_languages = len({x.language.split("-")[0] for x in media_info.audio_tracks if x.language})
-
-        context = {
-            "title": self.title.replace("$", "S"),
-            "year": self.year or "",
-            "season": f"S{self.season:02}",
-            "episode": f"E{self.number:02}",
-            "season_episode": f"S{self.season:02}E{self.number:02}",
-            "episode_name": self.name or "",
-            "tag": config.tag or "",
-            "source": self.service.__name__ if show_service else "",
-        }
-
-        # Video information
-        if primary_video_track:
-            resolution = primary_video_track.height
-            aspect_ratio = [int(float(plane)) for plane in primary_video_track.other_display_aspect_ratio[0].split(":")]
-            if len(aspect_ratio) == 1:
-                aspect_ratio.append(1)
-            if aspect_ratio[0] / aspect_ratio[1] not in (16 / 9, 4 / 3):
-                resolution = int(primary_video_track.width * (9 / 16))
-
-            context.update(
-                {
-                    "quality": f"{resolution}p",
-                    "resolution": str(resolution),
-                    "video": VIDEO_CODEC_MAP.get(primary_video_track.format, primary_video_track.format),
-                }
-            )
-
-            # HDR information
-            hdr_format = primary_video_track.hdr_format_commercial
-            trc = primary_video_track.transfer_characteristics or primary_video_track.transfer_characteristics_original
-            if hdr_format:
-                if (primary_video_track.hdr_format or "").startswith("Dolby Vision"):
-                    context["hdr"] = "DV"
-                    base_layer = DYNAMIC_RANGE_MAP.get(hdr_format)
-                    if base_layer and base_layer != "DV":
-                        context["hdr"] += f".{base_layer}"
-                else:
-                    context["hdr"] = DYNAMIC_RANGE_MAP.get(hdr_format, "")
-            elif trc and "HLG" in trc:
-                context["hdr"] = "HLG"
-            else:
-                context["hdr"] = ""
-
-            # High frame rate
-            frame_rate = float(primary_video_track.frame_rate)
-            context["hfr"] = "HFR" if frame_rate > 30 else ""
-
-        # Audio information
-        if primary_audio_track:
-            codec = primary_audio_track.format
-            channel_layout = primary_audio_track.channel_layout or primary_audio_track.channellayout_original
-
-            if channel_layout:
-                channels = float(sum({"LFE": 0.1}.get(position.upper(), 1) for position in channel_layout.split(" ")))
-            else:
-                channel_count = primary_audio_track.channel_s or primary_audio_track.channels or 0
-                channels = float(channel_count)
-
-            features = primary_audio_track.format_additionalfeatures or ""
-
-            context.update(
-                {
-                    "audio": AUDIO_CODEC_MAP.get(codec, codec),
-                    "audio_channels": f"{channels:.1f}",
-                    "audio_full": f"{AUDIO_CODEC_MAP.get(codec, codec)}{channels:.1f}",
-                    "atmos": "Atmos" if ("JOC" in features or primary_audio_track.joc) else "",
-                }
-            )
-
-        # Multi-language audio
-        if unique_audio_languages == 2:
-            context["dual"] = "DUAL"
-            context["multi"] = ""
-        elif unique_audio_languages > 2:
-            context["dual"] = ""
-            context["multi"] = "MULTi"
-        else:
-            context["dual"] = ""
-            context["multi"] = ""
-
-        return context
-
     def __str__(self) -> str:
         return "{title}{year} S{season:02}E{number:02} {name}".format(
             title=self.title,
-            year=f" {self.year}" if self.year else "",
+            year=f" {self.year}" if self.year and config.series_year else "",
             season=self.season,
             number=self.number,
             name=self.name or "",
         ).strip()
 
     def get_filename(self, media_info: MediaInfo, folder: bool = False, show_service: bool = True) -> str:
+        primary_video_track = next(iter(media_info.video_tracks), None)
+        primary_audio_track = next(iter(media_info.audio_tracks), None)
+        unique_audio_languages = len({x.language.split("-")[0] for x in media_info.audio_tracks if x.language})
+
+        # Title [Year] SXXEXX Name (or Title [Year] SXX if folder)
         if folder:
-            # For folders, use the series template but exclude episode-specific variables
+            name = f"{self.title}"
-            series_template = config.output_template.get("series")
+            if self.year and config.series_year:
-            if series_template:
+                name += f" {self.year}"
-                # Create a folder-friendly version by removing episode-specific variables
+            name += f" S{self.season:02}"
-                folder_template = series_template
+        else:
-                # Remove episode number and episode name from template for folders
+            name = "{title}{year} S{season:02}E{number:02} {name}".format(
-                folder_template = re.sub(r'\{episode\}', '', folder_template)
+                title=self.title.replace("$", "S"),  # e.g., Arli$$
-                folder_template = re.sub(r'\{episode_name\?\}', '', folder_template)
+                year=f" {self.year}" if self.year and config.series_year else "",
-                folder_template = re.sub(r'\{episode_name\}', '', folder_template)
+                season=self.season,
-                folder_template = re.sub(r'\{season_episode\}', '{season}', folder_template)
+                number=self.number,
+                name=self.name or "",
+            ).strip()
 
-                # Clean up any double separators that might result
+        if config.scene_naming:
-                folder_template = re.sub(r'\.{2,}', '.', folder_template)
+            # Resolution
-                folder_template = re.sub(r'\s{2,}', ' ', folder_template)
+            if primary_video_track:
-                folder_template = re.sub(r'^[\.\s]+|[\.\s]+$', '', folder_template)
+                resolution = primary_video_track.height
+                aspect_ratio = [
+                    int(float(plane)) for plane in primary_video_track.other_display_aspect_ratio[0].split(":")
+                ]
+                if len(aspect_ratio) == 1:
+                    # e.g., aspect ratio of 2 (2.00:1) would end up as `(2.0,)`, add 1
+                    aspect_ratio.append(1)
+                if aspect_ratio[0] / aspect_ratio[1] not in (16 / 9, 4 / 3):
+                    # We want the resolution represented in a 4:3 or 16:9 canvas.
+                    # If it's not 4:3 or 16:9, calculate as if it's inside a 16:9 canvas,
+                    # otherwise the track's height value is fine.
+                    # We are assuming this title is some weird aspect ratio so most
+                    # likely a movie or HD source, so it's most likely widescreen so
+                    # 16:9 canvas makes the most sense.
+                    resolution = int(primary_video_track.width * (9 / 16))
+                name += f" {resolution}p"
 
-                formatter = TemplateFormatter(folder_template)
+            # Service
-                context = self._build_template_context(media_info, show_service)
+            if show_service:
-                # Override season_episode with just season for folders
+                name += f" {self.service.__name__}"
-                context['season'] = f"S{self.season:02}"
 
-                folder_name = formatter.format(context)
+            # 'WEB-DL'
+            name += " WEB-DL"
 
-                # Keep the same separator style as the series template
+            # DUAL
-                if '.' in series_template and ' ' not in series_template:
+            if unique_audio_languages == 2:
-                    # Dot-based template - use dot separator for folders too
+                name += " DUAL"
-                    return sanitize_filename(folder_name, ".")
+
+            # MULTi
+            if unique_audio_languages > 2:
+                name += " MULTi"
+
+            # Audio Codec + Channels (+ feature)
+            if primary_audio_track:
+                codec = primary_audio_track.format
+                channel_layout = primary_audio_track.channel_layout or primary_audio_track.channellayout_original
+                if channel_layout:
+                    channels = float(
+                        sum({"LFE": 0.1}.get(position.upper(), 1) for position in channel_layout.split(" "))
+                    )
                 else:
-                    # Space-based template - use space separator
+                    channel_count = primary_audio_track.channel_s or primary_audio_track.channels or 0
-                    return sanitize_filename(folder_name, " ")
+                    channels = float(channel_count)
-            else:
-                # Fallback to simple naming if no template defined
-                name = f"{self.title}"
-                if self.year:
-                    name += f" {self.year}"
-                name += f" S{self.season:02}"
-                return sanitize_filename(name, " ")
 
-        # Use template from output_template (which includes scene_naming compatibility)
+                features = primary_audio_track.format_additionalfeatures or ""
-        # or fallback to default scene-style template
+                name += f" {AUDIO_CODEC_MAP.get(codec, codec)}{channels:.1f}"
-        template = (
+                if "JOC" in features or primary_audio_track.joc:
-            config.output_template.get("series")
+                    name += " Atmos"
-            or "{title}.{year?}.{season_episode}.{episode_name?}.{quality}.{source}.WEB-DL.{dual?}.{multi?}.{audio_full}.{atmos?}.{hfr?}.{video}-{tag}"
-        )
 
-        formatter = TemplateFormatter(template)
+            # Video (dynamic range + hfr +) Codec
-        context = self._build_template_context(media_info, show_service)
+            if primary_video_track:
-        return formatter.format(context)
+                codec = primary_video_track.format
+                hdr_format = primary_video_track.hdr_format_commercial
+                trc = (
+                    primary_video_track.transfer_characteristics
+                    or primary_video_track.transfer_characteristics_original
+                )
+                frame_rate = float(primary_video_track.frame_rate)
+                if hdr_format:
+                    if (primary_video_track.hdr_format or "").startswith("Dolby Vision"):
+                        name += " DV"
+                        if DYNAMIC_RANGE_MAP.get(hdr_format) and DYNAMIC_RANGE_MAP.get(hdr_format) != "DV":
+                            name += " HDR"
+                    else:
+                        name += f" {DYNAMIC_RANGE_MAP.get(hdr_format)} "
+                elif trc and "HLG" in trc:
+                    name += " HLG"
+                if frame_rate > 30:
+                    name += " HFR"
+                name += f" {VIDEO_CODEC_MAP.get(codec, codec)}"
+
+            if config.tag:
+                name += f"-{config.tag}"
+
+            return sanitize_filename(name)
+        else:
+            # Simple naming style without technical details - use spaces instead of dots
+            return sanitize_filename(name, " ")
 
 
 class Series(SortedKeyList, ABC):
@@ -236,7 +197,7 @@ class Series(SortedKeyList, ABC):
     def __str__(self) -> str:
         if not self:
             return super().__str__()
-        return self[0].title + (f" ({self[0].year})" if self[0].year else "")
+        return self[0].title + (f" ({self[0].year})" if self[0].year and config.series_year else "")
 
     def tree(self, verbose: bool = False) -> Tree:
         seasons = Counter(x.season for x in self)

unshackle/core/titles/movie.py

@@ -9,7 +9,7 @@ from sortedcontainers import SortedKeyList
 from unshackle.core.config import config
 from unshackle.core.constants import AUDIO_CODEC_MAP, DYNAMIC_RANGE_MAP, VIDEO_CODEC_MAP
 from unshackle.core.titles.title import Title
-from unshackle.core.utils.template_formatter import TemplateFormatter
+from unshackle.core.utilities import sanitize_filename
 
 
 class Movie(Title):
@@ -45,107 +45,100 @@ class Movie(Title):
         self.year = year
         self.description = description
 
-    def _build_template_context(self, media_info: MediaInfo, show_service: bool = True) -> dict:
-        """Build template context dictionary from MediaInfo."""
-        primary_video_track = next(iter(media_info.video_tracks), None)
-        primary_audio_track = next(iter(media_info.audio_tracks), None)
-        unique_audio_languages = len({x.language.split("-")[0] for x in media_info.audio_tracks if x.language})
-
-        context = {
-            "title": self.name.replace("$", "S"),
-            "year": self.year or "",
-            "tag": config.tag or "",
-            "source": self.service.__name__ if show_service else "",
-        }
-
-        # Video information
-        if primary_video_track:
-            resolution = primary_video_track.height
-            aspect_ratio = [int(float(plane)) for plane in primary_video_track.other_display_aspect_ratio[0].split(":")]
-            if len(aspect_ratio) == 1:
-                aspect_ratio.append(1)
-            if aspect_ratio[0] / aspect_ratio[1] not in (16 / 9, 4 / 3):
-                resolution = int(primary_video_track.width * (9 / 16))
-
-            context.update(
-                {
-                    "quality": f"{resolution}p",
-                    "resolution": str(resolution),
-                    "video": VIDEO_CODEC_MAP.get(primary_video_track.format, primary_video_track.format),
-                }
-            )
-
-            # HDR information
-            hdr_format = primary_video_track.hdr_format_commercial
-            trc = primary_video_track.transfer_characteristics or primary_video_track.transfer_characteristics_original
-            if hdr_format:
-                if (primary_video_track.hdr_format or "").startswith("Dolby Vision"):
-                    context["hdr"] = "DV"
-                    base_layer = DYNAMIC_RANGE_MAP.get(hdr_format)
-                    if base_layer and base_layer != "DV":
-                        context["hdr"] += f".{base_layer}"
-                else:
-                    context["hdr"] = DYNAMIC_RANGE_MAP.get(hdr_format, "")
-            elif trc and "HLG" in trc:
-                context["hdr"] = "HLG"
-            else:
-                context["hdr"] = ""
-
-            # High frame rate
-            frame_rate = float(primary_video_track.frame_rate)
-            context["hfr"] = "HFR" if frame_rate > 30 else ""
-
-        # Audio information
-        if primary_audio_track:
-            codec = primary_audio_track.format
-            channel_layout = primary_audio_track.channel_layout or primary_audio_track.channellayout_original
-
-            if channel_layout:
-                channels = float(sum({"LFE": 0.1}.get(position.upper(), 1) for position in channel_layout.split(" ")))
-            else:
-                channel_count = primary_audio_track.channel_s or primary_audio_track.channels or 0
-                channels = float(channel_count)
-
-            features = primary_audio_track.format_additionalfeatures or ""
-
-            context.update(
-                {
-                    "audio": AUDIO_CODEC_MAP.get(codec, codec),
-                    "audio_channels": f"{channels:.1f}",
-                    "audio_full": f"{AUDIO_CODEC_MAP.get(codec, codec)}{channels:.1f}",
-                    "atmos": "Atmos" if ("JOC" in features or primary_audio_track.joc) else "",
-                }
-            )
-
-        # Multi-language audio
-        if unique_audio_languages == 2:
-            context["dual"] = "DUAL"
-            context["multi"] = ""
-        elif unique_audio_languages > 2:
-            context["dual"] = ""
-            context["multi"] = "MULTi"
-        else:
-            context["dual"] = ""
-            context["multi"] = ""
-
-        return context
-
     def __str__(self) -> str:
         if self.year:
             return f"{self.name} ({self.year})"
         return self.name
 
     def get_filename(self, media_info: MediaInfo, folder: bool = False, show_service: bool = True) -> str:
-        # Use template from output_template (which includes scene_naming compatibility)
+        primary_video_track = next(iter(media_info.video_tracks), None)
-        # or fallback to default scene-style template
+        primary_audio_track = next(iter(media_info.audio_tracks), None)
-        template = (
+        unique_audio_languages = len({x.language.split("-")[0] for x in media_info.audio_tracks if x.language})
-            config.output_template.get("movies")
-            or "{title}.{year}.{quality}.{source}.WEB-DL.{dual?}.{multi?}.{audio_full}.{atmos?}.{hdr?}.{hfr?}.{video}-{tag}"
-        )
 
-        formatter = TemplateFormatter(template)
+        # Name (Year)
-        context = self._build_template_context(media_info, show_service)
+        name = str(self).replace("$", "S")  # e.g., Arli$$
-        return formatter.format(context)
+
+        if config.scene_naming:
+            # Resolution
+            if primary_video_track:
+                resolution = primary_video_track.height
+                aspect_ratio = [
+                    int(float(plane)) for plane in primary_video_track.other_display_aspect_ratio[0].split(":")
+                ]
+                if len(aspect_ratio) == 1:
+                    # e.g., aspect ratio of 2 (2.00:1) would end up as `(2.0,)`, add 1
+                    aspect_ratio.append(1)
+                if aspect_ratio[0] / aspect_ratio[1] not in (16 / 9, 4 / 3):
+                    # We want the resolution represented in a 4:3 or 16:9 canvas.
+                    # If it's not 4:3 or 16:9, calculate as if it's inside a 16:9 canvas,
+                    # otherwise the track's height value is fine.
+                    # We are assuming this title is some weird aspect ratio so most
+                    # likely a movie or HD source, so it's most likely widescreen so
+                    # 16:9 canvas makes the most sense.
+                    resolution = int(primary_video_track.width * (9 / 16))
+                name += f" {resolution}p"
+
+            # Service
+            if show_service:
+                name += f" {self.service.__name__}"
+
+            # 'WEB-DL'
+            name += " WEB-DL"
+
+            # DUAL
+            if unique_audio_languages == 2:
+                name += " DUAL"
+
+            # MULTi
+            if unique_audio_languages > 2:
+                name += " MULTi"
+
+            # Audio Codec + Channels (+ feature)
+            if primary_audio_track:
+                codec = primary_audio_track.format
+                channel_layout = primary_audio_track.channel_layout or primary_audio_track.channellayout_original
+                if channel_layout:
+                    channels = float(
+                        sum({"LFE": 0.1}.get(position.upper(), 1) for position in channel_layout.split(" "))
+                    )
+                else:
+                    channel_count = primary_audio_track.channel_s or primary_audio_track.channels or 0
+                    channels = float(channel_count)
+
+                features = primary_audio_track.format_additionalfeatures or ""
+                name += f" {AUDIO_CODEC_MAP.get(codec, codec)}{channels:.1f}"
+                if "JOC" in features or primary_audio_track.joc:
+                    name += " Atmos"
+
+            # Video (dynamic range + hfr +) Codec
+            if primary_video_track:
+                codec = primary_video_track.format
+                hdr_format = primary_video_track.hdr_format_commercial
+                trc = (
+                    primary_video_track.transfer_characteristics
+                    or primary_video_track.transfer_characteristics_original
+                )
+                frame_rate = float(primary_video_track.frame_rate)
+                if hdr_format:
+                    if (primary_video_track.hdr_format or "").startswith("Dolby Vision"):
+                        name += " DV"
+                        if DYNAMIC_RANGE_MAP.get(hdr_format) and DYNAMIC_RANGE_MAP.get(hdr_format) != "DV":
+                            name += " HDR"
+                    else:
+                        name += f" {DYNAMIC_RANGE_MAP.get(hdr_format)} "
+                elif trc and "HLG" in trc:
+                    name += " HLG"
+                if frame_rate > 30:
+                    name += " HFR"
+                name += f" {VIDEO_CODEC_MAP.get(codec, codec)}"
+
+            if config.tag:
+                name += f"-{config.tag}"
+
+            return sanitize_filename(name)
+        else:
+            # Simple naming style without technical details - use spaces instead of dots
+            return sanitize_filename(name, " ")
 
 
 class Movies(SortedKeyList, ABC):

unshackle/core/titles/song.py

@@ -10,7 +10,6 @@ from unshackle.core.config import config
 from unshackle.core.constants import AUDIO_CODEC_MAP
 from unshackle.core.titles.title import Title
 from unshackle.core.utilities import sanitize_filename
-from unshackle.core.utils.template_formatter import TemplateFormatter
 
 
 class Song(Title):
@@ -82,62 +81,45 @@ class Song(Title):
             artist=self.artist, album=self.album, year=self.year, track=self.track, name=self.name
         ).strip()
 
-    def _build_template_context(self, media_info: MediaInfo, show_service: bool = True) -> dict:
-        """Build template context dictionary from MediaInfo."""
-        primary_audio_track = next(iter(media_info.audio_tracks), None)
-
-        context = {
-            "artist": self.artist.replace("$", "S"),
-            "album": self.album.replace("$", "S"),
-            "title": self.name.replace("$", "S"),
-            "track_number": f"{self.track:02}",
-            "disc": f"{self.disc:02}" if self.disc > 1 else "",
-            "year": self.year or "",
-            "tag": config.tag or "",
-            "source": self.service.__name__ if show_service else "",
-        }
-
-        # Audio information
-        if primary_audio_track:
-            codec = primary_audio_track.format
-            channel_layout = primary_audio_track.channel_layout or primary_audio_track.channellayout_original
-
-            if channel_layout:
-                channels = float(sum({"LFE": 0.1}.get(position.upper(), 1) for position in channel_layout.split(" ")))
-            else:
-                channel_count = primary_audio_track.channel_s or primary_audio_track.channels or 0
-                channels = float(channel_count)
-
-            features = primary_audio_track.format_additionalfeatures or ""
-
-            context.update(
-                {
-                    "audio": AUDIO_CODEC_MAP.get(codec, codec),
-                    "audio_channels": f"{channels:.1f}",
-                    "audio_full": f"{AUDIO_CODEC_MAP.get(codec, codec)}{channels:.1f}",
-                    "atmos": "Atmos" if ("JOC" in features or primary_audio_track.joc) else "",
-                }
-            )
-
-        return context
-
     def get_filename(self, media_info: MediaInfo, folder: bool = False, show_service: bool = True) -> str:
+        audio_track = next(iter(media_info.audio_tracks), None)
+        codec = audio_track.format
+        channel_layout = audio_track.channel_layout or audio_track.channellayout_original
+        if channel_layout:
+            channels = float(sum({"LFE": 0.1}.get(position.upper(), 1) for position in channel_layout.split(" ")))
+        else:
+            channel_count = audio_track.channel_s or audio_track.channels or 0
+            channels = float(channel_count)
+
+        features = audio_track.format_additionalfeatures or ""
+
         if folder:
-            # For folders, use simple naming: "Artist - Album (Year)"
+            # Artist - Album (Year)
-            name = f"{self.artist} - {self.album}"
+            name = str(self).split(" / ")[0]
-            if self.year:
+        else:
-                name += f" ({self.year})"
+            # NN. Song Name
+            name = str(self).split(" / ")[1]
+
+        if config.scene_naming:
+            # Service
+            if show_service:
+                name += f" {self.service.__name__}"
+
+            # 'WEB-DL'
+            name += " WEB-DL"
+
+            # Audio Codec + Channels (+ feature)
+            name += f" {AUDIO_CODEC_MAP.get(codec, codec)}{channels:.1f}"
+            if "JOC" in features or audio_track.joc:
+                name += " Atmos"
+
+            if config.tag:
+                name += f"-{config.tag}"
+
+            return sanitize_filename(name, " ")
+        else:
+            # Simple naming style without technical details
             return sanitize_filename(name, " ")
-
-        # Use template from output_template (which includes scene_naming compatibility)
-        # or fallback to default scene-style template
-        template = (
-            config.output_template.get("songs") or "{track_number}.{title}.{source?}.WEB-DL.{audio_full}.{atmos?}-{tag}"
-        )
-
-        formatter = TemplateFormatter(template)
-        context = self._build_template_context(media_info, show_service)
-        return formatter.format(context)
 
 
 class Album(SortedKeyList, ABC):

unshackle/core/utils/template_formatter.py

@@ -1,147 +0,0 @@
-import logging
-import re
-from typing import Any, Dict, List
-
-from unshackle.core.utilities import sanitize_filename
-
-
-class TemplateFormatter:
-    """
-    Template formatter for custom filename patterns.
-
-    Supports variable substitution and conditional variables.
-    Example: '{title}.{year}.{quality?}.{source}-{tag}'
-    """
-
-    def __init__(self, template: str):
-        """Initialize the template formatter.
-
-        Args:
-            template: Template string with variables in {variable} format
-        """
-        self.template = template
-        self.variables = self._extract_variables()
-
-    def _extract_variables(self) -> List[str]:
-        """Extract all variables from the template."""
-        pattern = r"\{([^}]+)\}"
-        matches = re.findall(pattern, self.template)
-        return [match.strip() for match in matches]
-
-    def format(self, context: Dict[str, Any]) -> str:
-        """Format the template with the provided context.
-
-        Args:
-            context: Dictionary containing variable values
-
-        Returns:
-            Formatted filename string
-
-        Raises:
-            ValueError: If required template variables are missing from context
-        """
-        logger = logging.getLogger(__name__)
-
-        # Validate that all required variables are present
-        is_valid, missing_vars = self.validate(context)
-        if not is_valid:
-            error_msg = f"Missing required template variables: {', '.join(missing_vars)}"
-            logger.error(error_msg)
-            raise ValueError(error_msg)
-
-        try:
-            result = self.template
-
-            for variable in self.variables:
-                placeholder = "{" + variable + "}"
-                is_conditional = variable.endswith("?")
-
-                if is_conditional:
-                    # Remove the ? for conditional variables
-                    var_name = variable[:-1]
-                    value = context.get(var_name, "")
-
-                    if value:
-                        # Replace with actual value, ensuring it's string and safe
-                        safe_value = str(value).strip()
-                        result = result.replace(placeholder, safe_value)
-                    else:
-                        # Remove the placeholder entirely for empty conditional variables
-                        result = result.replace(placeholder, "")
-                else:
-                    # Regular variable
-                    value = context.get(variable, "")
-                    if value is None:
-                        logger.warning(f"Template variable '{variable}' is None, using empty string")
-                        value = ""
-
-                    safe_value = str(value).strip()
-                    result = result.replace(placeholder, safe_value)
-
-            # Clean up multiple consecutive dots/separators and other artifacts
-            result = re.sub(r"\.{2,}", ".", result)  # Multiple dots -> single dot
-            result = re.sub(r"\s{2,}", " ", result)  # Multiple spaces -> single space
-            result = re.sub(r"^[\.\s]+|[\.\s]+$", "", result)  # Remove leading/trailing dots and spaces
-            result = re.sub(r"\.-", "-", result)  # Remove dots before dashes (for dot-based templates)
-            result = re.sub(r"[\.\s]+\)", ")", result)  # Remove dots/spaces before closing parentheses
-
-            # Determine the appropriate separator based on template style
-            # If the template contains spaces (like Plex-friendly), preserve them
-            if " " in self.template and "." not in self.template:
-                # Space-based template (Plex-friendly) - use space separator
-                result = sanitize_filename(result, spacer=" ")
-            else:
-                # Dot-based template (scene-style) - use dot separator
-                result = sanitize_filename(result, spacer=".")
-
-            # Final validation - ensure we have a non-empty result
-            if not result or result.isspace():
-                logger.warning("Template formatting resulted in empty filename, using fallback")
-                return "untitled"
-
-            logger.debug(f"Template formatted successfully: '{self.template}' -> '{result}'")
-            return result
-
-        except Exception as e:
-            logger.error(f"Error formatting template '{self.template}': {e}")
-            # Return a safe fallback filename
-            fallback = f"error_formatting_{hash(self.template) % 10000}"
-            logger.warning(f"Using fallback filename: {fallback}")
-            return fallback
-
-    def validate(self, context: Dict[str, Any]) -> tuple[bool, List[str]]:
-        """Validate that all required variables are present in context.
-
-        Args:
-            context: Dictionary containing variable values
-
-        Returns:
-            Tuple of (is_valid, missing_variables)
-        """
-        missing = []
-
-        for variable in self.variables:
-            is_conditional = variable.endswith("?")
-            var_name = variable[:-1] if is_conditional else variable
-
-            # Only check non-conditional variables
-            if not is_conditional and var_name not in context:
-                missing.append(var_name)
-
-        return len(missing) == 0, missing
-
-    def get_required_variables(self) -> List[str]:
-        """Get list of required (non-conditional) variables."""
-        required = []
-        for variable in self.variables:
-            if not variable.endswith("?"):
-                required.append(variable)
-        return required
-
-    def get_optional_variables(self) -> List[str]:
-        """Get list of optional (conditional) variables."""
-        optional = []
-        for variable in self.variables:
-            if variable.endswith("?"):
-                optional.append(variable[:-1])  # Remove the ?
-        return optional

unshackle/unshackle-example.yaml

@@ -10,45 +10,15 @@ tag_imdb_tmdb: true
 # Set terminal background color (custom option not in CONFIG.md)
 set_terminal_bg: false
 
-# File naming is now controlled via output_template (see below)
+# Set file naming convention
-# Default behavior provides scene-style naming similar to the old scene_naming: true
+#  true for style - Prime.Suspect.S07E01.The.Final.Act.Part.One.1080p.ITV.WEB-DL.AAC2.0.H.264
-#
+#  false for style - Prime Suspect S07E01 The Final Act - Part One
-# BACKWARD COMPATIBILITY: The old scene_naming option is still supported:
+scene_naming: true
-# scene_naming: true  -> Equivalent to scene-style templates (dot-separated)
-# scene_naming: false -> Equivalent to Plex-friendly templates (space-separated)
-# Note: output_template takes precedence over scene_naming if both are defined
 
-# Custom output templates for filenames
+# Whether to include the year in series names for episodes and folders (default: true)
-# When not defined, defaults to scene-style naming equivalent to the old scene_naming: true
+#  true for style - Show Name (2023) S01E01 Episode Name
-# Available variables: {title}, {year}, {season}, {episode}, {season_episode}, {episode_name},
+#  false for style - Show Name S01E01 Episode Name
-#                     {quality}, {resolution}, {source}, {audio}, {audio_channels}, {audio_full},
+series_year: true
-#                     {video}, {hdr}, {hfr}, {atmos}, {dual}, {multi}, {tag}
-# Conditional variables (included only if present): Add ? suffix like {year?}, {episode_name?}, {hdr?}
-# Uncomment and customize the templates below:
-#
-# output_template:
-#   # Scene-style naming (dot-separated) - Default behavior when no template is defined
-#   movies: '{title}.{year}.{quality}.{source}.WEB-DL.{dual?}.{multi?}.{audio_full}.{atmos?}.{hdr?}.{hfr?}.{video}-{tag}'
-#   series: '{title}.{year?}.{season_episode}.{episode_name?}.{quality}.{source}.WEB-DL.{dual?}.{multi?}.{audio_full}.{atmos?}.{hdr?}.{hfr?}.{video}-{tag}'
-#
-#   # Plex-friendly naming (space-separated, clean format)
-#   # movies: '{title} ({year}) {quality}'
-#   # series: '{title} {season_episode} {episode_name?}'
-#
-#   # Minimal naming (basic info only)
-#   # movies: '{title}.{year}.{quality}'
-#   # series: '{title}.{season_episode}.{episode_name?}'
-#
-#   # Custom scene-style with specific elements
-#   # movies: '{title}.{year}.{quality}.{hdr?}.{source}.WEB-DL.{audio_full}.{video}-{tag}'
-#   # series: '{title}.{year?}.{season_episode}.{episode_name?}.{quality}.{hdr?}.{source}.WEB-DL.{audio_full}.{atmos?}.{video}-{tag}'
-#
-# Example outputs:
-# Scene movies: 'The.Matrix.1999.1080p.NF.WEB-DL.DDP5.1.H.264-EXAMPLE'
-# Scene movies (HDR): 'Dune.2021.2160p.HBO.WEB-DL.DDP5.1.HDR10.H.265-EXAMPLE'
-# Scene series: 'Breaking.Bad.2008.S01E01.Pilot.1080p.NF.WEB-DL.DDP5.1.H.264-EXAMPLE'
-# Plex movies: 'The Matrix (1999) 1080p'
-# Plex series: 'Breaking Bad S01E01 Pilot'
 
 # Check for updates from GitHub repository on startup (default: true)
 update_checks: true
@@ -136,16 +106,16 @@ remote_cdm:
     secret: secret_key
 
   - name: "decrypt_labs_chrome"
-    type: "decrypt_labs" # Required to identify as DecryptLabs CDM
+    type: "decrypt_labs"  # Required to identify as DecryptLabs CDM
-    device_name: "ChromeCDM" # Scheme identifier - must match exactly
+    device_name: "ChromeCDM"  # Scheme identifier - must match exactly
     device_type: CHROME
     system_id: 4464 # Doesn't matter
     security_level: 3
     host: "https://keyxtractor.decryptlabs.com"
-    secret: "your_decrypt_labs_api_key_here" # Replace with your API key
+    secret: "your_decrypt_labs_api_key_here"  # Replace with your API key
   - name: "decrypt_labs_l1"
     type: "decrypt_labs"
-    device_name: "L1" # Scheme identifier - must match exactly
+    device_name: "L1"  # Scheme identifier - must match exactly
     device_type: ANDROID
     system_id: 4464
     security_level: 1
@@ -154,7 +124,7 @@ remote_cdm:
 
   - name: "decrypt_labs_l2"
     type: "decrypt_labs"
-    device_name: "L2" # Scheme identifier - must match exactly
+    device_name: "L2"  # Scheme identifier - must match exactly
     device_type: ANDROID
     system_id: 4464
     security_level: 2
@@ -163,7 +133,7 @@ remote_cdm:
 
   - name: "decrypt_labs_playready_sl2"
     type: "decrypt_labs"
-    device_name: "SL2" # Scheme identifier - must match exactly
+    device_name: "SL2"  # Scheme identifier - must match exactly
     device_type: PLAYREADY
     system_id: 0
     security_level: 2000
@@ -172,7 +142,7 @@ remote_cdm:
 
   - name: "decrypt_labs_playready_sl3"
     type: "decrypt_labs"
-    device_name: "SL3" # Scheme identifier - must match exactly
+    device_name: "SL3"  # Scheme identifier - must match exactly
     device_type: PLAYREADY
     system_id: 0
     security_level: 3000

unshackle/vaults/MySQL.py

@@ -131,16 +131,27 @@ class MySQL(Vault):
         if any(isinstance(kid, UUID) for kid, key_ in kid_keys.items()):
             kid_keys = {kid.hex if isinstance(kid, UUID) else kid: key_ for kid, key_ in kid_keys.items()}
 
+        if not kid_keys:
+            return 0
+
         conn = self.conn_factory.get()
         cursor = conn.cursor()
 
         try:
+            placeholders = ",".join(["%s"] * len(kid_keys))
+            cursor.execute(f"SELECT kid FROM `{service}` WHERE kid IN ({placeholders})", list(kid_keys.keys()))
+            existing_kids = {row["kid"] for row in cursor.fetchall()}
+
+            new_keys = {kid: key for kid, key in kid_keys.items() if kid not in existing_kids}
+
+            if not new_keys:
+                return 0
+
             cursor.executemany(
-                # TODO: SQL injection risk
+                f"INSERT INTO `{service}` (kid, key_) VALUES (%s, %s)",
-                f"INSERT IGNORE INTO `{service}` (kid, key_) VALUES (%s, %s)",
+                new_keys.items(),
-                kid_keys.items(),
             )
-            return cursor.rowcount
+            return len(new_keys)
         finally:
             conn.commit()
             cursor.close()

unshackle/vaults/SQLite.py

@@ -102,16 +102,27 @@ class SQLite(Vault):
         if any(isinstance(kid, UUID) for kid, key_ in kid_keys.items()):
             kid_keys = {kid.hex if isinstance(kid, UUID) else kid: key_ for kid, key_ in kid_keys.items()}
 
+        if not kid_keys:
+            return 0
+
         conn = self.conn_factory.get()
         cursor = conn.cursor()
 
         try:
+            placeholders = ",".join(["?"] * len(kid_keys))
+            cursor.execute(f"SELECT kid FROM `{service}` WHERE kid IN ({placeholders})", list(kid_keys.keys()))
+            existing_kids = {row[0] for row in cursor.fetchall()}
+
+            new_keys = {kid: key for kid, key in kid_keys.items() if kid not in existing_kids}
+
+            if not new_keys:
+                return 0
+
             cursor.executemany(
-                # TODO: SQL injection risk
+                f"INSERT INTO `{service}` (kid, key_) VALUES (?, ?)",
-                f"INSERT OR IGNORE INTO `{service}` (kid, key_) VALUES (?, ?)",
+                new_keys.items(),
-                kid_keys.items(),
             )
-            return cursor.rowcount
+            return len(new_keys)
         finally:
             conn.commit()
             cursor.close()