v6.6.1

NEWS.md

@@ -1,5 +1,13 @@
 # 📰 Picopt News
 
+## v6.6.1
+
+### Fixes
+
+- Animated WebP images with zero-duration frames no longer fail to optimize.
+- The `Optimizing formats` summary is no longer repeated once per directory when
+  using `-W` or per-directory `.picopt.yaml` files.
+
 ## v6.6.0
 
 ### Fixes
@@ -91,7 +99,7 @@
 - Faster metadata extraction
 - Defer animated image duration doublecheck to only WebP animated and only at
   handler time. Speeds up other animated images.
-- Use rich_argparse to format cli help.
+- Use rich\_argparse to format cli help.
 
 ## v6.4.0
 
@@ -233,7 +241,7 @@
     - Support converting losslessly converting MPO to JPEG (choose primary
       image)
     - Internal oxipng replaces external optipng for png compression.
-    - Better support for preserving EXIF, ICC_PROFILE, & XMP data across
+    - Better support for preserving EXIF, ICC\_PROFILE, & XMP data across
       optimization and conversion.
     - `--destroy-metadata` option becomes `--strip-metadata`
     - `--near-lossless` option for lossless WebP.
@@ -276,7 +284,7 @@
 
 ## v3.3.1
 
-- Upstream treestamps fixes crashes and check_config option.
+- Upstream treestamps fixes crashes and check\_config option.
 
 ## v3.3.0
 
@@ -376,7 +384,7 @@
     - EPub support. ePub contents are never converted.
     - TIFF support
 - Timestamps
-    - Timestamps are now kept in .picopt_treestamps.yaml files.
+    - Timestamps are now kept in .picopt\_treestamps.yaml files.
     - Picopt will convert and clean up old style timestamps.
     - Timestamps are now recorded after optimizing every image for each image
       individually instead of directories, preserving progress.
@@ -426,7 +434,7 @@
 ## v1.6.3
 
 - Don't use pngout on 16 bit pngs because it crashes
-- Fix broken option -D --optimize_after
+- Fix broken option -D --optimize\_after
 
 ## v1.6.2
 
@@ -488,7 +496,7 @@
 
 - Print found picopt timestamps
 - Lots of linting
-- Fix jpeg_multithread flag
+- Fix jpeg\_multithread flag
 - moved tests out of picopt module
 
 ## v1.3.2

package.json

@@ -86,7 +86,7 @@
     "eslint-plugin-security": "^4.0.1",
     "eslint-plugin-sonarjs": "^4.1.0",
     "eslint-plugin-toml": "^1.4.0",
-    "eslint-plugin-unicorn": "^70.0.0",
+    "eslint-plugin-unicorn": "^71.0.0",
     "eslint-plugin-yml": "^3.5.0",
     "prettier": "^3.9.4",
     "prettier-plugin-nginx": "^1.0.3",

picopt/config/__init__.py

@@ -394,6 +394,8 @@ def _build_config(
         args: Namespace | None = None,
         dir_config_files: tuple[Path, ...] = (),
         modname: str = PROGRAM_NAME,
+        *,
+        print_summary: bool = False,
     ) -> Configuration:
         """
         Build a fully-layered, normalized confuse Configuration.
@@ -421,7 +423,7 @@ def _build_config(
         self._set_after(config_program)
         self._set_memory_limit(config_program)
         self._set_timestamps(config_program)
-        self.set_format_handler_map(config_program)
+        self.set_format_handler_map(config_program, print_summary=print_summary)
         return config
 
     @staticmethod
@@ -434,7 +436,7 @@ def get_config(
         self, args: Namespace | None = None, modname: str = PROGRAM_NAME
     ) -> PicoptSettings:
         """Get the validated, frozen settings layered from defaults/env/args."""
-        config = self._build_config(args, modname=modname)
+        config = self._build_config(args, modname=modname, print_summary=True)
         # Validate (via _config_to_settings) before persisting so a bad
         # command line can't poison a config file. get_config passes no
         # directory files, so -w output round-trips via -C unchanged.

picopt/config/handlers.py

@@ -136,32 +136,18 @@ def _set_format_handler_stages(
         if stages is not None:
             handler_stages[handler_cls] = stages
 
-    def set_format_handler_map(self, config: Subview) -> None:
-        """Probe handlers for the requested formats and store availability."""
-        all_format_strs = self._get_config_set(config, "formats", "extra_formats")
-        config["formats"].set(tuple(sorted(all_format_strs)))
-        convert_to = self._get_config_set(config, "convert_to")
-        # Write the upcased lists back so template validation accepts
-        # lowercase user input for -x and -c exactly as it does for -f.
-        if extra_formats := self._get_config_set(config, "extra_formats"):
-            config["extra_formats"].set(tuple(sorted(extra_formats)))
-        if convert_to:
-            config["convert_to"].set(tuple(sorted(convert_to)))
-
-        disabled_list: list[str] | None = config["disable_programs"].get(list)
-        disabled_program_names = (
-            frozenset(disabled_list) if disabled_list else frozenset()
-        )
-
-        handler_stages: dict[type[Handler], tuple[Tool, ...]] = {}
-        for handler_cls in _enabled_handler_classes(all_format_strs):
-            self._set_format_handler_stages(
-                handler_cls, handler_stages, disabled_program_names
-            )
-        # Build the verbose-output summary with the routing layer's own
-        # decision function so the log can never drift from what the walk
-        # actually does. repack=True for archives applies the same
-        # convert/CAN_PACK gates the repack pass will.
+    def _log_formats_summary(
+        self,
+        verbose: int,
+        all_format_strs: frozenset[str],
+        convert_to: frozenset[str],
+        handler_stages: dict[type[Handler], tuple[Tool, ...]],
+    ) -> None:
+        """Log the run-wide "Optimizing formats" banner."""
+        # Build the summary with the routing layer's own decision function
+        # so the log can never drift from what the walk actually does.
+        # repack=True for archives applies the same convert/CAN_PACK gates
+        # the repack pass will.
         handled_format_strs: set[str] = set()
         convert_format_strs: dict[str, set[str]] = {}
         routes = registry.routes_by_format()
@@ -184,7 +170,40 @@ def set_format_handler_map(self, config: Subview) -> None:
                 convert_format_strs.setdefault(picked.OUTPUT_FORMAT_STR, set()).add(
                     file_format.format_str
                 )
+        self._print_formats_config(verbose, handled_format_strs, convert_format_strs)
+
+    def set_format_handler_map(
+        self, config: Subview, *, print_summary: bool = False
+    ) -> None:
+        """Probe handlers for the requested formats and store availability."""
+        all_format_strs = self._get_config_set(config, "formats", "extra_formats")
+        config["formats"].set(tuple(sorted(all_format_strs)))
+        convert_to = self._get_config_set(config, "convert_to")
+        # Write the upcased lists back so template validation accepts
+        # lowercase user input for -x and -c exactly as it does for -f.
+        if extra_formats := self._get_config_set(config, "extra_formats"):
+            config["extra_formats"].set(tuple(sorted(extra_formats)))
+        if convert_to:
+            config["convert_to"].set(tuple(sorted(convert_to)))
+
+        disabled_list: list[str] | None = config["disable_programs"].get(list)
+        disabled_program_names = (
+            frozenset(disabled_list) if disabled_list else frozenset()
+        )
+
+        handler_stages: dict[type[Handler], tuple[Tool, ...]] = {}
+        for handler_cls in _enabled_handler_classes(all_format_strs):
+            self._set_format_handler_stages(
+                handler_cls, handler_stages, disabled_program_names
+            )
         config["computed"]["handler_stages"].set(handler_stages)
 
-        verbose: int = config["verbose"].get(int)
-        self._print_formats_config(verbose, handled_format_strs, convert_format_strs)
+        # The banner is a run-wide summary. Emit it only for the top-level
+        # build, never for the per-directory .picopt.yaml resolutions that
+        # rebuild this config once per directory during the walk (which, with
+        # -W or any planted .picopt.yaml, would repeat it for every directory).
+        if print_summary:
+            verbose: int = config["verbose"].get(int)
+            self._log_formats_summary(
+                verbose, all_format_strs, convert_to, handler_stages
+            )

picopt/plugins/__init__.py

@@ -221,30 +221,52 @@ def pick_route_handler(
     """
     if file_format is None:
         return None
-    handler_cls: type[Handler] | None = None
-    if convert and (not file_format.archive or repack):
-        handler_cls = _pick_convert_handler(convert_chain, convert_to, handler_stages)
+    handler_cls = _pick_convert_handler(
+        convert_chain,
+        convert_to,
+        handler_stages,
+        file_format,
+        convert=convert,
+        repack=repack,
+    )
     if (
         handler_cls is None
         and native is not None
         and is_pipeline_available(native, handler_stages)
     ):
         handler_cls = native
-    if (
-        repack
-        and handler_cls is not None
-        and not (issubclass(handler_cls, ContainerHandler) and handler_cls.CAN_PACK)
-    ):
+    if repack and not _can_pack_repack(handler_cls):
         handler_cls = None
     return handler_cls
 
 
+def _can_pack_repack(handler_cls: type[Handler] | None) -> bool:
+    """Report whether the handler is a container that can pack itself back up."""
+    return (
+        handler_cls is not None
+        and issubclass(handler_cls, ContainerHandler)
+        and handler_cls.CAN_PACK
+    )
+
+
 def _pick_convert_handler(
     convert_chain: tuple[type[Handler], ...],
     convert_to: frozenset[str],
     handler_stages: Mapping,
+    file_format: FileFormat,
+    *,
+    convert: bool,
+    repack: bool,
 ) -> type[Handler] | None:
-    """First convert candidate the user asked for whose pipeline is available."""
+    """
+    First convert candidate the user asked for whose pipeline is available.
+
+    Returns ``None`` when conversion doesn't apply at all: the caller didn't
+    request it, or it's an archive outside the repack pass (archives only
+    convert while repacking).
+    """
+    if not convert or (file_format.archive and not repack):
+        return None
     for candidate in convert_chain:
         if candidate.OUTPUT_FORMAT_STR not in convert_to:
             continue

picopt/plugins/base/handler.py

@@ -320,13 +320,17 @@ def _cleanup_after_optimize_get_return_data(
         final_data_buffer.close()
         return return_data
 
+    def _should_replace(self, bytes_in: int, bytes_out: int) -> bool:
+        """Report whether the new buffer is a real improvement worth keeping."""
+        if self.config.dry_run or bytes_out <= 0:
+            return False
+        return bytes_out < bytes_in or self.config.bigger
+
     def _cleanup_after_optimize(self, final_data_buffer: BinaryIO) -> ReportStats:
         """Replace the old file with the better one or discard the new wasteful one."""
         bytes_in = self.path_info.bytes_in()
         bytes_out = self._get_buffer_len(final_data_buffer)
-        replaced = not self.config.dry_run and (
-            bytes_out > 0 and (bytes_out < bytes_in or self.config.bigger)
-        )
+        replaced = self._should_replace(bytes_in, bytes_out)
         return_data = self._cleanup_after_optimize_get_return_data(
             final_data_buffer, replaced=replaced
         )

picopt/plugins/webp/animated.py

@@ -229,7 +229,10 @@ def img2webp_args(self) -> tuple[str, ...]:
             if frame_path is None:
                 continue
             if frame_duration is not None:
-                out += ["-d", str(frame_duration)]
+                # img2webp rejects durations <= 0 ("Invalid negative
+                # duration"). Some sources (e.g. scraped animated WebPs)
+                # carry 0ms frame durations, so clamp to its 1ms minimum.
+                out += ["-d", str(max(1, int(frame_duration)))]
             out.append(str(frame_path))
         return tuple(out)
 

picopt/walk/skip.py

@@ -63,43 +63,44 @@ def _log_skip(self, reason: str, path_info: PathInfo, *, warn: bool) -> None:
         self._reporter.stats.record_skipped()
         self._reporter.progress.mark_skipped()
 
-    def _is_skippable(self, path_info: PathInfo) -> bool:
-        """Handle things that are not optimizable files."""
-        reason = ""
-        warn = False
-
+    def _skip_reason_fs(self, path_info: PathInfo) -> tuple[str, bool]:
+        """Disk checks, done last for performance and skipped inside archives."""
         path = path_info.path
+        if self._in_archive or not path:
+            return "", False
+        if not path.exists():
+            return "not found", True
+        fs_stat = path_info.stat()
+        if fs_stat is not None and not (
+            S_ISREG(fs_stat.st_mode) or S_ISDIR(fs_stat.st_mode)
+        ):
+            # FIFOs, sockets, device nodes: opening a FIFO blocks forever.
+            return "not a regular file", False
+        return "", False
 
-        # File types
+    def _skip_reason(self, path_info: PathInfo) -> tuple[str, bool]:
+        """Return ``(reason, warn)`` for an unoptimizable file, else ``("", False)``."""
+        path = path_info.path
         basename = Path(path_info.name()).name
         if not self._config.symlinks and path and path.is_symlink():
-            reason = "symlink"
-        elif basename == DIR_CONFIG_FILENAME:
-            reason = "picopt config"
-        elif basename in self._TIMESTAMPS_FILENAMES:
+            return "symlink", False
+        if basename == DIR_CONFIG_FILENAME:
+            return "picopt config", False
+        if basename in self._TIMESTAMPS_FILENAMES:
             legacy = "legacy " if basename == OLD_TIMESTAMPS_NAME else ""
-            reason = f"{legacy}timestamp"
-        elif is_path_ignored(
+            return f"{legacy}timestamp", False
+        if is_path_ignored(
             self._config,
             path_info.archive_pseudo_path(),
             ignore_case=not path_info.is_case_sensitive,
         ):
-            reason = "ignored"
-        elif not self._in_archive and path and not path.exists():
-            # Check disk last for performance
-            reason = "not found"
-            warn = True
-        elif (
-            not self._in_archive
-            and path
-            and (fs_stat := path_info.stat()) is not None
-            and not (S_ISREG(fs_stat.st_mode) or S_ISDIR(fs_stat.st_mode))
-        ):
-            # FIFOs, sockets, device nodes: opening a FIFO blocks forever.
-            reason = "not a regular file"
+            return "ignored", False
+        return self._skip_reason_fs(path_info)
 
+    def _is_skippable(self, path_info: PathInfo) -> bool:
+        """Handle things that are not optimizable files."""
+        reason, warn = self._skip_reason(path_info)
         self._log_skip(reason, path_info, warn=warn)
-
         return bool(reason)
 
     def _clean_up_working_files(self, path: Path) -> None:

picopt/walk/walk.py

@@ -352,6 +352,24 @@ def _walk_top_path(self, top_path: Path, scheduler: Scheduler) -> None:
         )
         self.walk_file(path_info, scheduler)
 
+    @staticmethod
+    def _count_stops_here(
+        settings: PicoptSettings,
+        path: Path,
+        name: str,
+        *,
+        is_symlink: bool,
+        is_dir: bool,
+    ) -> bool:
+        """Whether the walk would not recurse into ``path`` (mirror walk_file)."""
+        return bool(
+            not settings.recurse
+            or (not settings.symlinks and is_symlink)
+            or name in WalkSkipper.SKIP_FILENAMES
+            or not is_dir
+            or is_path_ignored(settings, path, ignore_case=False)
+        )
+
     def _count(
         self,
         top_path: Path,
@@ -372,12 +390,8 @@ def _count(
         settings = self._dirconfig.get_settings(
             top_path, path if is_dir else path.parent
         )
-        if (
-            not settings.recurse
-            or (not settings.symlinks and is_symlink)
-            or name in WalkSkipper.SKIP_FILENAMES
-            or not is_dir
-            or is_path_ignored(settings, path, ignore_case=False)
+        if self._count_stops_here(
+            settings, path, name, is_symlink=is_symlink, is_dir=is_dir
         ):
             return 1
         try: