ffmpeg-normalize 1.37.2__tar.gz → 1.37.4__tar.gz

{ffmpeg_normalize-1.37.2 → ffmpeg_normalize-1.37.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffmpeg-normalize
-Version: 1.37.2
+Version: 1.37.4
 Summary: Normalize audio via ffmpeg
 Keywords: ffmpeg,normalize,audio
 Author: Werner Robitza

{ffmpeg_normalize-1.37.2 → ffmpeg_normalize-1.37.4}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["uv_build>=0.8.14,<0.9.0"]
+requires = ["uv_build>=0.8.14,<1.0.0"]
 build-backend = "uv_build"
 
 [project]
 name = "ffmpeg-normalize"
-version = "1.37.2"
+version = "1.37.4"
 description = "Normalize audio via ffmpeg"
 readme = "README.md"
 license = "MIT"
@@ -52,19 +52,12 @@ package-data = {"ffmpeg_normalize" = ["data/**/*.json"]}
 dev = [
     "pytest>=8.1.1,<9",
     "ruff>=0.12.11",
-    "mypy>=1.0.0",
     "types-tqdm",
     "shtab>=1.7.0",
+    "ty>=0.0.24",
 ]
 
-[tool.mypy]
-python_version = "3.13"
-ignore_missing_imports = true
-exclude = ["build"]
-namespace_packages = false
-no_implicit_optional = true
-check_untyped_defs = true
-warn_return_any = true
-warn_unused_ignores = true
-show_error_codes = true
+[tool.ty.rules]
+invalid-argument-type = "warn"
+too-many-positional-arguments = "warn"
 

{ffmpeg_normalize-1.37.2 → ffmpeg_normalize-1.37.4}/src/ffmpeg_normalize/__main__.py

@@ -197,7 +197,7 @@ def create_parser() -> argparse.ArgumentParser:
         help=textwrap.dedent(
             """\
         Write ReplayGain tags to the original file without normalizing.
-        This mode will overwrite the input file and ignore other options.
+        This mode will overwrite the input file and ignore other options. It will strip all ReplayGain tags.
         Only works with EBU normalization, and only with .mp3, .mp4/.m4a, .ogg, .opus for now.
         """
         ),

{ffmpeg_normalize-1.37.2 → ffmpeg_normalize-1.37.4}/src/ffmpeg_normalize/_media_file.py

@@ -332,8 +332,10 @@ class MediaFile:
                 "ReplayGain tagging is enabled. Proceeding with tag calculation/application."
             )
             self._run_replaygain()
-
-        if not self.ffmpeg_normalize.replaygain:
+        else:
+            # Strip any existing ReplayGain tags from the output file
+            # since they are no longer accurate after normalization
+            self._strip_replaygain_tags(self.output_file)
             _logger.info(f"Normalized file written to {self.output_file}")
 
     def _run_replaygain(self) -> None:
@@ -461,6 +463,103 @@ class MediaFile:
             f"Successfully wrote replaygain tags to input file {self.input_file}"
         )
 
+    def _strip_replaygain_tags(self, output_file: str) -> None:
+        """
+        Strip ReplayGain tags from the output file after normalization.
+
+        This ensures that old ReplayGain tags from the input are removed,
+        since they are no longer accurate after normalization.
+
+        Args:
+            output_file (str): Path to the output file to strip tags from
+        """
+        _logger.debug(f"Stripping ReplayGain tags from {output_file}")
+
+        output_file_ext = os.path.splitext(output_file)[1]
+        if output_file_ext == ".mp3":
+            try:
+                mp3 = MP3(output_file, ID3=ID3)
+                if not mp3.tags:
+                    return
+                # Remove REPLAYGAIN_* tags
+                tags_to_remove = [
+                    key for key in mp3.tags if key.startswith("TXXX:REPLAYGAIN_")
+                ]
+                for tag in tags_to_remove:
+                    del mp3.tags[tag]
+                if tags_to_remove:
+                    mp3.save()
+                    _logger.debug(
+                        f"Stripped {len(tags_to_remove)} ReplayGain tag(s) from {output_file}"
+                    )
+            except Exception as e:
+                _logger.warning(
+                    f"Could not strip ReplayGain tags from {output_file}: {e}"
+                )
+        elif output_file_ext in [".mp4", ".m4a", ".m4v", ".mov"]:
+            try:
+                mp4 = MP4(output_file)
+                if not mp4.tags:
+                    return
+                # Remove REPLAYGAIN_* tags
+                tags_to_remove = [
+                    key
+                    for key in mp4.tags
+                    if "REPLAYGAIN_" in key.upper() or "REPLAYGAIN" in key.upper()
+                ]
+                for tag in tags_to_remove:
+                    del mp4.tags[tag]
+                if tags_to_remove:
+                    mp4.save()
+                    _logger.debug(
+                        f"Stripped {len(tags_to_remove)} ReplayGain tag(s) from {output_file}"
+                    )
+            except Exception as e:
+                _logger.warning(
+                    f"Could not strip ReplayGain tags from {output_file}: {e}"
+                )
+        elif output_file_ext == ".ogg":
+            try:
+                ogg = OggVorbis(output_file)
+                # Remove REPLAYGAIN_* tags (case-insensitive)
+                tags_to_remove = [
+                    key for key in ogg.keys() if key.upper().startswith("REPLAYGAIN_")
+                ]
+                for tag in tags_to_remove:
+                    del ogg[tag]
+                if tags_to_remove:
+                    ogg.save()
+                    _logger.debug(
+                        f"Stripped {len(tags_to_remove)} ReplayGain tag(s) from {output_file}"
+                    )
+            except Exception as e:
+                _logger.warning(
+                    f"Could not strip ReplayGain tags from {output_file}: {e}"
+                )
+        elif output_file_ext == ".opus":
+            try:
+                opus = OggOpus(output_file)
+                # Remove R128_* tags (Opus uses R128 instead of REPLAYGAIN, case-insensitive)
+                tags_to_remove = [
+                    key for key in opus.keys() if key.upper().startswith("R128_")
+                ]
+                for tag in tags_to_remove:
+                    del opus[tag]
+                if tags_to_remove:
+                    opus.save()
+                    _logger.debug(
+                        f"Stripped {len(tags_to_remove)} R128 tag(s) from {output_file}"
+                    )
+            except Exception as e:
+                _logger.warning(
+                    f"Could not strip ReplayGain tags from {output_file}: {e}"
+                )
+        else:
+            # For other formats, we don't need to strip tags
+            _logger.debug(
+                f"Skipping ReplayGain tag stripping for {output_file_ext} (not supported/needed)"
+            )
+
     def _can_write_output_video(self) -> bool:
         """
         Determine whether the output file can contain video at all.