logreducer 3.5.1__tar.gz → 3.5.2__tar.gz

{logreducer-3.5.1 → logreducer-3.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logreducer
-Version: 3.5.1
+Version: 3.5.2
 Summary: Reduce GB-scale logs to a representative sample - streaming Python library and CLI with pattern mining and anomaly detection
 Keywords: log,logging,reduction,analysis,pattern-extraction,memory-efficient,streaming,anomaly-detection
 Author: HyperI Team
@@ -22,10 +22,10 @@ Requires-Dist: psutil>=7.2.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: numpy>=2.0.0
 Requires-Dist: scikit-learn>=1.5.0
-Requires-Dist: typer>=0.25.0
+Requires-Dist: typer>=0.27.3
 Requires-Dist: clickhouse-connect>=1.0 ; extra == 'clickhouse'
-Requires-Dist: xxhash>=3.0.0 ; extra == 'enhanced'
-Requires-Dist: datasketch>=1.5.0 ; extra == 'enhanced'
+Requires-Dist: xxhash>=4.0.1 ; extra == 'enhanced'
+Requires-Dist: datasketch>=2.0.0 ; extra == 'enhanced'
 Requires-Dist: confluent-kafka>=2.14.0 ; extra == 'kafka'
 Requires-Dist: sqlalchemy>=2.0.30 ; extra == 'sql'
 Maintainer: HyperI Team
@@ -438,7 +438,7 @@ Individually: `uv run ruff format`, `uv run ruff check --fix`,
 | Assume a reused `LogReducer` starts clean | Nothing -- `_reset_components()` rebuilds them per run | The dedup seen-set, both Drain3 miners and the fuzzy LSH accumulate per line. Carried into the next run they drop every line as already-seen and return empty (`core.py`) |
 | Share one deduplicator across hybrid's two passes | Rebuild it before the anomaly pass | The pattern pass consumes the seen-set, so the anomaly pass sees everything as seen and no anomalies survive. Hybrid silently degrades to pattern-only (`core.py`) |
 | Assume an unknown config keyword is ignored | Read the `ValueError` and fix the name | A silently dropped override means a user's tuning quietly does nothing (`core.py`) |
-| Read `LogPattern.template` as the final Drain3 template | Treat it as a first-seen snapshot until #5 lands | `extract_patterns` captures `cluster.get_template()` when a cluster FIRST appears, before later lines widen slots to `<*>`, so a varying cluster stores its raw first line. The `<*>`-count priority boost then runs on that stale snapshot (#5, open) |
+| Assume every template is the final Drain3 one | Allow for a cluster the `max_clusters` cap evicted | `extract_patterns` re-reads each template from the live cluster once the feed ends, so a varying cluster carries its `<*>` slots and the priority boost counts them. A cluster LRU-evicted mid-feed is gone by then and keeps the template it had when first seen (`patterns.py`) |
 | Hand-edit the version | Land a conventional commit and let semantic-release do it | The old regime wrote `VERSION` by hand and took five commits to get tagging working. CONTRIBUTING makes it a standing rule |
 
 ### Where this sits

{logreducer-3.5.1 → logreducer-3.5.2}/README.md

@@ -394,7 +394,7 @@ Individually: `uv run ruff format`, `uv run ruff check --fix`,
 | Assume a reused `LogReducer` starts clean | Nothing -- `_reset_components()` rebuilds them per run | The dedup seen-set, both Drain3 miners and the fuzzy LSH accumulate per line. Carried into the next run they drop every line as already-seen and return empty (`core.py`) |
 | Share one deduplicator across hybrid's two passes | Rebuild it before the anomaly pass | The pattern pass consumes the seen-set, so the anomaly pass sees everything as seen and no anomalies survive. Hybrid silently degrades to pattern-only (`core.py`) |
 | Assume an unknown config keyword is ignored | Read the `ValueError` and fix the name | A silently dropped override means a user's tuning quietly does nothing (`core.py`) |
-| Read `LogPattern.template` as the final Drain3 template | Treat it as a first-seen snapshot until #5 lands | `extract_patterns` captures `cluster.get_template()` when a cluster FIRST appears, before later lines widen slots to `<*>`, so a varying cluster stores its raw first line. The `<*>`-count priority boost then runs on that stale snapshot (#5, open) |
+| Assume every template is the final Drain3 one | Allow for a cluster the `max_clusters` cap evicted | `extract_patterns` re-reads each template from the live cluster once the feed ends, so a varying cluster carries its `<*>` slots and the priority boost counts them. A cluster LRU-evicted mid-feed is gone by then and keeps the template it had when first seen (`patterns.py`) |
 | Hand-edit the version | Land a conventional commit and let semantic-release do it | The old regime wrote `VERSION` by hand and took five commits to get tagging working. CONTRIBUTING makes it a standing rule |
 
 ### Where this sits

{logreducer-3.5.1 → logreducer-3.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "logreducer"
-version = "3.5.1"
+version = "3.5.2"
 description = "Reduce GB-scale logs to a representative sample - streaming Python library and CLI with pattern mining and anomaly detection"
 readme = "README.md"
 license = "Apache-2.0"
@@ -40,7 +40,7 @@ dependencies = [
     "loguru>=0.7.3",
     "numpy>=2.0.0",
     "scikit-learn>=1.5.0",
-    "typer>=0.25.0",
+    "typer>=0.27.3",
 ]
 
 [[project.authors]]
@@ -53,8 +53,8 @@ email = "dev@hyperi.io"
 
 [project.optional-dependencies]
 enhanced = [
-    "xxhash>=3.0.0",
-    "datasketch>=1.5.0",
+    "xxhash>=4.0.1",
+    "datasketch>=2.0.0",
 ]
 sql = ["sqlalchemy>=2.0.30"]
 clickhouse = ["clickhouse-connect>=1.0"]
@@ -72,6 +72,7 @@ logreducer = "logreducer.cli:main"
 
 [tool.uv]
 index-strategy = "unsafe-best-match"
+exclude-newer = "7 days"
 override-dependencies = []
 
 [[tool.uv.index]]
@@ -150,6 +151,7 @@ ignore = [
 fixable = ["ALL"]
 unfixable = []
 dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+external = ["V"]
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = [
@@ -164,6 +166,15 @@ dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
     "PT012",
     "RUF043",
 ]
+"src/**" = [
+    "D105",
+    "D107",
+]
+"src/logreducer/sampling.py" = ["S608"]
+"src/logreducer/clickhouse.py" = ["S608"]
+"src/logreducer/core.py" = ["S311"]
+"src/logreducer/memory.py" = ["S311"]
+"src/logreducer/target.py" = ["S311"]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"
@@ -260,30 +271,33 @@ exclude = [
     "scripts/",
 ]
 
+[tool.vulture]
+min_confidence = 80
+
 [tool.vermin]
 targets = ["3.12"]
 no_tips = true
 
 [tool.hatch.build.targets.sdist]
 exclude = [
-    "/ci",
-    "/GEMINI.md",
     "/hyperi-ai",
-    "/.windsurf",
-    "/CURSOR.md",
-    "/CLAUDE.md",
     "/.claude",
     "/.gemini",
+    "/CURSOR.md",
+    "/CLAUDE.md",
+    "/.cursor",
+    "/ci",
+    "/GEMINI.md",
     "/.github/copilot-instructions.md",
     "/STATE.md",
-    "/.cursor",
+    "/.windsurf",
 ]
 
 [dependency-groups]
 dev = [
     "pytest>=9.0.0",
     "pytest-cov>=7.0.0",
-    "ruff>=0.15.0",
+    "ruff>=0.16.10",
     "ty>=0.0.34",
     "mypy>=2.0",
     "bandit[toml]>=1.7.0",
@@ -293,7 +307,7 @@ dev = [
     "sqlalchemy>=2.0.30",
     "clickhouse-connect>=1.0",
     "confluent-kafka>=2.14.0",
-    "testcontainers[clickhouse,kafka,postgres,mysql]>=4.14.0",
+    "testcontainers[clickhouse,kafka,postgres,mysql]>=4.15.0",
     "psycopg[binary]>=3.2",
     "pymysql>=1.1.0",
     "python-dotenv>=1.0.0",

{logreducer-3.5.1 → logreducer-3.5.2}/pyproject.toml.orig

@@ -6,7 +6,7 @@ build-backend = "uv_build"
 
 [project]
 name = "logreducer"
-version = "3.5.1"
+version = "3.5.2"
 authors = [
     { name = "HyperI Team", email = "dev@hyperi.io" },
 ]
@@ -48,13 +48,13 @@ dependencies = [
     "loguru>=0.7.3",
     "numpy>=2.0.0",
     "scikit-learn>=1.5.0",
-    "typer>=0.25.0",
+    "typer>=0.27.3",
 ]
 
 [project.optional-dependencies]
 enhanced = [
-    "xxhash>=3.0.0",
-    "datasketch>=1.5.0",
+    "xxhash>=4.0.1",
+    "datasketch>=2.0.0",
 ]
 sql = [
     "sqlalchemy>=2.0.30",
@@ -78,6 +78,7 @@ logreducer = "logreducer.cli:main"
 
 [tool.uv]
 index-strategy = "unsafe-best-match"
+exclude-newer = "7 days"
 override-dependencies = []
 index = [
     { name = "pypi", url = "https://pypi.org/simple", default = true },
@@ -160,6 +161,9 @@ fixable = [
 ]
 unfixable = []
 dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+external = [
+    "V",
+]
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = [
@@ -174,6 +178,25 @@ dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
     "PT012",
     "RUF043",
 ]
+"src/**" = [
+    "D105",
+    "D107",
+]
+"src/logreducer/sampling.py" = [
+    "S608",
+]
+"src/logreducer/clickhouse.py" = [
+    "S608",
+]
+"src/logreducer/core.py" = [
+    "S311",
+]
+"src/logreducer/memory.py" = [
+    "S311",
+]
+"src/logreducer/target.py" = [
+    "S311",
+]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"
@@ -278,6 +301,9 @@ exclude = [
     "scripts/",
 ]
 
+[tool.vulture]
+min_confidence = 80
+
 [tool.vermin]
 targets = [
     "3.12",
@@ -286,24 +312,24 @@ no_tips = true
 
 [tool.hatch.build.targets.sdist]
 exclude = [
-    "/ci",
-    "/GEMINI.md",
     "/hyperi-ai",
-    "/.windsurf",
-    "/CURSOR.md",
-    "/CLAUDE.md",
     "/.claude",
     "/.gemini",
+    "/CURSOR.md",
+    "/CLAUDE.md",
+    "/.cursor",
+    "/ci",
+    "/GEMINI.md",
     "/.github/copilot-instructions.md",
     "/STATE.md",
-    "/.cursor",
+    "/.windsurf",
 ]
 
 [dependency-groups]
 dev = [
     "pytest>=9.0.0",
     "pytest-cov>=7.0.0",
-    "ruff>=0.15.0",
+    "ruff>=0.16.10",
     "ty>=0.0.34",
     "mypy>=2.0",
     "bandit[toml]>=1.7.0",
@@ -313,7 +339,7 @@ dev = [
     "sqlalchemy>=2.0.30",
     "clickhouse-connect>=1.0",
     "confluent-kafka>=2.14.0",
-    "testcontainers[clickhouse,kafka,postgres,mysql]>=4.14.0",
+    "testcontainers[clickhouse,kafka,postgres,mysql]>=4.15.0",
     "psycopg[binary]>=3.2",
     "pymysql>=1.1.0",
     "python-dotenv>=1.0.0",

{logreducer-3.5.1 → logreducer-3.5.2}/src/logreducer/anomaly.py

@@ -1,6 +1,4 @@
-"""
-Anomaly detection utilities
-"""
+"""Anomaly detection utilities."""
 
 from loguru import logger
 
@@ -15,7 +13,7 @@ except ImportError:
 
 
 class AnomalyDetector:
-    """Detect anomalous log lines"""
+    """Detect anomalous log lines."""
 
     def __init__(self, contamination: float = 0.1):
         self.contamination = contamination
@@ -25,8 +23,7 @@ class AnomalyDetector:
             logger.warning("scikit-learn not available, anomaly detection disabled")
 
     def detect_anomalies(self, lines: list[str]) -> tuple[list[str], list[str]]:
-        """
-        Separate anomalous and normal lines
+        """Separate anomalous and normal lines.
 
         Returns:
             (anomalous_lines, normal_lines)

{logreducer-3.5.1 → logreducer-3.5.2}/src/logreducer/core.py

@@ -1,6 +1,4 @@
-"""
-Core LogReducer implementation
-"""
+"""Core LogReducer implementation."""
 
 import json
 import os
@@ -10,7 +8,7 @@ from dataclasses import replace
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal, overload
 
 from .anomaly import AnomalyDetector
 from .config import BigDialConfig, OutputFormat, ProcessingLevel, ProcessingMode, get_preset_config
@@ -24,8 +22,7 @@ from .temporal import TemporalProcessor
 
 
 class LogReducer:
-    """
-    Main log reduction class
+    """Main log reduction class.
 
     Example:
         reducer = LogReducer(level="enhanced")
@@ -41,8 +38,7 @@ class LogReducer:
         config: BigDialConfig | None = None,
         **kwargs: Any,
     ) -> None:
-        """
-        Initialize LogReducer
+        """Initialize LogReducer.
 
         Args:
             level: Processing level (standard/enhanced/maximum)
@@ -134,13 +130,41 @@ class LogReducer:
         else:
             self.temporal_processor = None
 
+    @overload
+    def reduce(
+        self,
+        source: Source,
+        output_file: str | None = None,
+        return_metadata: Literal[False] = False,
+        sink: Sink | None = None,
+    ) -> list[str]: ...
+
+    @overload
+    def reduce(
+        self,
+        source: Source,
+        output_file: str | None = None,
+        *,
+        return_metadata: Literal[True],
+        sink: Sink | None = None,
+    ) -> dict[str, Any]: ...
+
+    @overload
     def reduce(
         self,
         source: Source,
         output_file: str | None = None,
         return_metadata: bool = False,
         sink: Sink | None = None,
-    ) -> list[str] | dict:
+    ) -> list[str] | dict[str, Any]: ...
+
+    def reduce(
+        self,
+        source: Source,
+        output_file: str | None = None,
+        return_metadata: bool = False,
+        sink: Sink | None = None,
+    ) -> list[str] | dict[str, Any]:
         """Reduce a source of log lines to a representative sample.
 
         This is the core entry point: it operates on an abstraction, not on IO.
@@ -241,12 +265,37 @@ class LogReducer:
             }
         return result_lines
 
+    @overload
+    def process_file(
+        self,
+        input_file: str,
+        output_file: str | None = None,
+        return_metadata: Literal[False] = False,
+    ) -> list[str]: ...
+
+    @overload
+    def process_file(
+        self,
+        input_file: str,
+        output_file: str | None = None,
+        *,
+        return_metadata: Literal[True],
+    ) -> dict[str, Any]: ...
+
+    @overload
+    def process_file(
+        self,
+        input_file: str,
+        output_file: str | None = None,
+        return_metadata: bool = False,
+    ) -> list[str] | dict[str, Any]: ...
+
     def process_file(
         self,
         input_file: str,
         output_file: str | None = None,
         return_metadata: bool = False,
-    ) -> list[str] | dict:
+    ) -> list[str] | dict[str, Any]:
         """Reduce a log file - convenience wrapper over reduce() + FileSource.
 
         Args:
@@ -302,7 +351,7 @@ class LogReducer:
         return unique_lines
 
     def _process_anomaly_mode(self, source: Source) -> list[str]:
-        """Process using anomaly detection"""
+        """Process using anomaly detection."""
         if not self.anomaly_detector:
             if self.config.enable_logging:
                 self.logger.warning("Anomaly detector not available, falling back to pattern mode")
@@ -329,7 +378,7 @@ class LogReducer:
         return result
 
     def _process_temporal_mode(self, source: Source) -> list[str]:
-        """Process using temporal analysis"""
+        """Process using temporal analysis."""
         if not self.temporal_processor:
             if self.config.enable_logging:
                 self.logger.warning("Temporal processor not available, falling back to pattern mode")
@@ -356,7 +405,7 @@ class LogReducer:
         return result
 
     def _process_hybrid_mode(self, source: Source) -> list[str]:
-        """Process using combined approach"""
+        """Process using combined approach."""
         if self.config.enable_logging:
             self.logger.info("Hybrid mode: combining pattern and anomaly detection")
 
@@ -400,7 +449,7 @@ class LogReducer:
         }
 
     def _save_output(self, lines: list[str], output_file: str) -> None:
-        """Save output to file in specified format"""
+        """Save output to file in specified format."""
         output_path = Path(output_file)
         output_path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -453,7 +502,7 @@ class LogReducer:
                 self.logger.info(f"Metadata saved to {meta_file}")
 
     def _print_summary(self) -> None:
-        """Log processing summary"""
+        """Log processing summary."""
         self.logger.info("\n" + "=" * 60)
         self.logger.info("LOG REDUCTION SUMMARY")
         self.logger.info("=" * 60)
@@ -474,7 +523,7 @@ class LogReducer:
         self.logger.info("=" * 60)
 
     def estimate_processing(self, file_path: str) -> dict:
-        """Estimate processing requirements before running"""
+        """Estimate processing requirements before running."""
         file_size = os.path.getsize(file_path)
         file_size_gb = file_size / (1024**3)
 

{logreducer-3.5.1 → logreducer-3.5.2}/src/logreducer/logging_config.py

@@ -26,7 +26,8 @@ from typing import TYPE_CHECKING
 from loguru import logger
 
 if TYPE_CHECKING:
-    from loguru import Logger
+    # Read by get_logger's quoted return annotation, which vulture does not parse.
+    from loguru import Logger  # noqa: V104
 
 # Solarized palette (https://ethanschoonover.com/solarized/) for the console
 # sink - readable on both light and dark terminal backgrounds.

{logreducer-3.5.1 → logreducer-3.5.2}/src/logreducer/memory.py

@@ -1,6 +1,4 @@
-"""
-Memory management and monitoring utilities
-"""
+"""Memory management and monitoring utilities."""
 
 import gc
 import os
@@ -13,7 +11,7 @@ import psutil
 
 
 class MemoryMonitor:
-    """Monitor and control memory usage during processing"""
+    """Monitor and control memory usage during processing."""
 
     def __init__(self, max_memory_gb: float = 1.0):
         self.max_memory_gb = max_memory_gb
@@ -57,7 +55,7 @@ class MemoryMonitor:
         return current_gb, is_safe
 
     def get_current_usage_gb(self) -> float:
-        """Get current memory usage in GB"""
+        """Get current memory usage in GB."""
         current = self.process.memory_info().rss
         # Update peak usage
         if current > self.peak_usage_bytes:
@@ -65,7 +63,7 @@ class MemoryMonitor:
         return float(current / (1024**3))
 
     def get_peak_usage_gb(self) -> float:
-        """Get peak memory usage in GB"""
+        """Get peak memory usage in GB."""
         # Update current peak if needed
         current = self.process.memory_info().rss
         if current > self.peak_usage_bytes:
@@ -84,12 +82,12 @@ class MemoryMonitor:
         return bool(current > self.max_memory_bytes)
 
     def reset(self) -> None:
-        """Reset peak memory tracking"""
+        """Reset peak memory tracking."""
         current_usage = self.process.memory_info().rss
         self.peak_usage_bytes = current_usage
 
     def estimate_file_strategy(self, file_size_bytes: int) -> str:
-        """Determine processing strategy"""
+        """Determine processing strategy."""
         file_size_gb = file_size_bytes / (1024**3)
 
         if file_size_gb < self.max_memory_gb * 0.2:
@@ -101,14 +99,14 @@ class MemoryMonitor:
 
 
 class StreamingProcessor:
-    """Process large files with constant memory usage"""
+    """Process large files with constant memory usage."""
 
     def __init__(self, memory_monitor: MemoryMonitor):
         self.memory_monitor = memory_monitor
         self.chunk_size = memory_monitor.safe_chunk_size
 
     def read_file_streaming(self, file_path: str) -> Iterator[str]:
-        """Read file with minimal memory usage"""
+        """Read file with minimal memory usage."""
         file_size = os.path.getsize(file_path)
         strategy = self.memory_monitor.estimate_file_strategy(file_size)
 
@@ -223,7 +221,7 @@ class BoundedDeduplicator:
         self.stats = {"total": 0, "unique": 0, "duplicates": 0}
 
     def is_duplicate(self, line: str) -> bool:
-        """Check if line is duplicate"""
+        """Check if line is duplicate."""
         self.stats["total"] += 1
         line_hash = self.hash_func(line)
 
@@ -241,7 +239,7 @@ class BoundedDeduplicator:
         return False
 
     def deduplicate_lines(self, lines: Iterable[str]) -> Iterator[str]:
-        """Deduplicate a stream of lines"""
+        """Deduplicate a stream of lines."""
         for line in lines:
             if not self.is_duplicate(line):
                 yield line

{logreducer-3.5.1 → logreducer-3.5.2}/src/logreducer/patterns.py

@@ -121,6 +121,14 @@ class PatternExtractor:
             if len(pattern.examples) < self.config.examples_per_pattern:
                 pattern.examples.append(line)
 
+        # Later lines widen a cluster's slots to <*>, so the stored template is
+        # re-read once the feed ends; an LRU-evicted cluster keeps its snapshot.
+        clusters = self.miner.drain.id_to_cluster
+        for cluster_id, pattern in pattern_map.items():
+            cluster = clusters.get(cluster_id)
+            if cluster is not None:
+                pattern.template = cluster.get_template()
+
         patterns = list(pattern_map.values())
 
         # Apply filters

{logreducer-3.5.1 → logreducer-3.5.2}/src/logreducer/sinks.py

@@ -30,7 +30,8 @@ class Sink(Protocol):
     iterate lazily rather than materialising the whole batch.
     """
 
-    def write(self, lines: Iterable[str]) -> int: ...
+    def write(self, lines: Iterable[str]) -> int:
+        """Write ``lines`` to the destination and return how many were written."""
 
 
 class FileSink:
@@ -54,6 +55,14 @@ class FileSink:
         self.output_format = fmt
 
     def write(self, lines: Iterable[str]) -> int:
+        """Write ``lines`` to ``path`` in the configured format, replacing the file.
+
+        Args:
+            lines: The reduced lines, consumed once.
+
+        Returns:
+            The number of lines written.
+        """
         output_path = Path(self.path)
         output_path.parent.mkdir(parents=True, exist_ok=True)
 

{logreducer-3.5.1 → logreducer-3.5.2}/src/logreducer/temporal.py

@@ -1,6 +1,4 @@
-"""
-Temporal processing and time-aware pattern extraction
-"""
+"""Temporal processing and time-aware pattern extraction."""
 
 import re
 from collections import defaultdict
@@ -13,7 +11,7 @@ from drain3 import TemplateMiner
 
 @dataclass
 class LogEntry:
-    """Parsed log entry with timestamp"""
+    """Parsed log entry with timestamp."""
 
     raw_line: str
     timestamp: datetime | None = None
@@ -22,7 +20,7 @@ class LogEntry:
 
 
 class TimestampParser:
-    """Parse timestamps from various formats"""
+    """Parse timestamps from various formats."""
 
     PATTERNS = [
         (r"\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}", "%Y-%m-%d %H:%M:%S"),
@@ -34,7 +32,7 @@ class TimestampParser:
     LEVEL_PATTERN = re.compile(r"\b(DEBUG|INFO|WARN|ERROR|CRITICAL)\b", re.I)
 
     def parse_line(self, line: str, line_number: int = 0) -> LogEntry:
-        """Parse log line"""
+        """Parse log line."""
         entry = LogEntry(raw_line=line.strip(), line_number=line_number)
 
         # Extract timestamp
@@ -61,7 +59,7 @@ class TimestampParser:
 
 
 class TemporalProcessor:
-    """Time-aware log processing"""
+    """Time-aware log processing."""
 
     def __init__(self, window_minutes: int = 60):
         self.window_minutes = window_minutes
@@ -69,7 +67,7 @@ class TemporalProcessor:
         self.miners_by_window: dict[int, TemplateMiner] = {}
 
     def process_temporal(self, lines: list[str]) -> dict:
-        """Process with temporal awareness"""
+        """Process with temporal awareness."""
         entries = [self.parser.parse_line(line, i) for i, line in enumerate(lines)]
 
         timed = [e for e in entries if e.timestamp]
@@ -91,7 +89,7 @@ class TemporalProcessor:
         return results
 
     def _extract_temporal_patterns(self, entries: list[LogEntry]) -> list[dict]:
-        """Extract patterns with time context"""
+        """Extract patterns with time context."""
         patterns = []
         windows = defaultdict(list)
 
@@ -112,11 +110,10 @@ class TemporalProcessor:
                 self.miners_by_window[window_key] = TemplateMiner(config=config)
 
             miner = self.miners_by_window[window_key]
+            cluster_ids = [miner.add_log_message(entry.raw_line)["cluster_id"] for entry in window_entries]
 
-            for entry in window_entries:
-                result = miner.add_log_message(entry.raw_line)
-                cluster_id = result["cluster_id"]
-
+            # Templates are read once the window is fed, after later lines have widened their slots.
+            for entry, cluster_id in zip(window_entries, cluster_ids, strict=True):
                 patterns.append(
                     {
                         "template": miner.drain.id_to_cluster[cluster_id].get_template(),
@@ -129,29 +126,26 @@ class TemporalProcessor:
         return patterns
 
     def _extract_timeless_patterns(self, entries: list[LogEntry]) -> list[dict]:
-        """Extract patterns without timestamps"""
+        """Extract patterns without timestamps."""
         from drain3.template_miner_config import TemplateMinerConfig
 
         config = TemplateMinerConfig()
         config.snapshot_interval_minutes = 0  # Disable snapshots
         config.snapshot_compress_state = False
         miner = TemplateMiner(config=config)
-        patterns = []
+        cluster_ids = [miner.add_log_message(entry.raw_line)["cluster_id"] for entry in entries]
 
-        for entry in entries:
-            result = miner.add_log_message(entry.raw_line)
-            cluster_id = result["cluster_id"]
-            patterns.append(
-                {
-                    "template": miner.drain.id_to_cluster[cluster_id].get_template(),
-                    "example": entry.raw_line,
-                }
-            )
-
-        return patterns
+        # Templates are read once every entry is fed, after later lines have widened their slots.
+        return [
+            {
+                "template": miner.drain.id_to_cluster[cluster_id].get_template(),
+                "example": entry.raw_line,
+            }
+            for entry, cluster_id in zip(entries, cluster_ids, strict=True)
+        ]
 
     def _analyze_distribution(self, entries: list[LogEntry]) -> dict:
-        """Analyze time distribution"""
+        """Analyze time distribution."""
         dist: dict[str, Any] = {"hourly": defaultdict(int), "levels": defaultdict(int)}
 
         for entry in entries: