horde-model-reference 2.1.0__tar.gz → 2.1.2__tar.gz

{horde_model_reference-2.1.0/src/horde_model_reference.egg-info → horde_model_reference-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: horde_model_reference
-Version: 2.1.0
+Version: 2.1.2
 Summary: A helper library providing a way to work with the lists of generation models, utility models, and any other related files required for the AI-Horde ecosystem.
 Author-email: tazlin <tazlin.on.github@gmail.com>, db0 <mail@dbzer0.com>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE

{horde_model_reference-2.1.0 → horde_model_reference-2.1.2}/src/horde_model_reference/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = 'v2.1.0'
-__version_tuple__ = version_tuple = (2, 1, 0)
+__version__ = version = 'v2.1.2'
+__version_tuple__ = version_tuple = (2, 1, 2)
 
 __commit_id__ = commit_id = None

{horde_model_reference-2.1.0 → horde_model_reference-2.1.2}/src/horde_model_reference/analytics/text_model_parser.py

@@ -49,7 +49,9 @@ VARIANT_PATTERNS = [
 
 # Quantization patterns
 QUANT_PATTERNS = [
-    r"\b(Q[2-8](?:_K)?(?:_[SMLH])?)\b",  # Q4_K_M, Q8, Q5_K_S
+    r"\b(Q[2-8]_K(?:_[SMLH])?)\b",  # Q4_K_M, Q5_K_S, Q6_K (K-quants with optional size)
+    r"\b(Q[2-8]_[01])\b",  # Q4_0, Q5_0, Q5_1, Q8_0 (legacy/standard quants)
+    r"\b(Q[2-8])\b",  # Q4, Q8 (bare quant indicators)
     r"\b(GGUF|GGML|GPTQ|AWQ|EXL2)\b",
     r"\b(fp16|fp32|int8|int4)\b",
 ]

{horde_model_reference-2.1.0 → horde_model_reference-2.1.2}/src/horde_model_reference/integrations/horde_api_models.py

@@ -236,12 +236,168 @@ class _StatsLookup(BaseModel):
     total: dict[str, int] = Field(default_factory=dict)
 
 
+def _strip_quantization_suffix(model_name: str) -> str:
+    """Strip quantization suffix from a model name, preserving size.
+
+    This is different from get_base_model_name which strips BOTH size and quantization.
+    This function only strips quantization, keeping the size suffix.
+
+    Args:
+        model_name: Model name potentially with quantization suffix.
+
+    Returns:
+        Model name without quantization suffix, but with size preserved.
+
+    Example:
+        "Lumimaid-v0.2-8B-Q8_0" -> "Lumimaid-v0.2-8B"
+        "Lumimaid-v0.2-8B" -> "Lumimaid-v0.2-8B"
+        "koboldcpp/Lumimaid-v0.2-8B-Q4_K_M" -> "koboldcpp/Lumimaid-v0.2-8B"
+    """
+    import re
+
+    # Quantization patterns to strip (same as text_model_parser.QUANT_PATTERNS but as suffix)
+    quant_suffix_patterns = [
+        r"[-_](Q[2-8]_K(?:_[SMLH])?)$",  # -Q4_K_M, -Q5_K_S
+        r"[-_](Q[2-8]_[01])$",  # -Q4_0, -Q5_0, -Q8_0
+        r"[-_](Q[2-8])$",  # -Q4, -Q8
+        r"[-_](GGUF|GGML|GPTQ|AWQ|EXL2)$",
+        r"[-_](fp16|fp32|int8|int4)$",
+    ]
+
+    result = model_name
+    for pattern in quant_suffix_patterns:
+        result = re.sub(pattern, "", result, flags=re.IGNORECASE)
+
+    return result
+
+
+def _build_base_name_index(model_names: list[str]) -> dict[str, list[str]]:
+    """Build an index mapping base model names to all matching model names.
+
+    This enables aggregating stats across quantization variants (e.g., Q4_K_M, Q8_0)
+    and different backend prefixes (aphrodite/, koboldcpp/).
+
+    Args:
+        model_names: List of model names from API stats (may include backend prefixes
+            and quantization suffixes).
+
+    Returns:
+        Dictionary mapping lowercase base model names to lists of original model names
+        (lowercase) that match that base.
+
+    Example:
+        Input: ["koboldcpp/Lumimaid-v0.2-8B", "koboldcpp/Lumimaid-v0.2-8B-Q8_0",
+                "aphrodite/NeverSleep/Lumimaid-v0.2-8B"]
+        Output: {"lumimaid-v0.2": ["koboldcpp/lumimaid-v0.2-8b",
+                                   "koboldcpp/lumimaid-v0.2-8b-q8_0",
+                                   "aphrodite/neversleep/lumimaid-v0.2-8b"]}
+    """
+    from horde_model_reference.analytics.text_model_parser import get_base_model_name
+    from horde_model_reference.meta_consts import strip_backend_prefix
+
+    base_name_index: dict[str, list[str]] = {}
+
+    for model_name in model_names:
+        # Store lowercase version for case-insensitive matching
+        model_name_lower = model_name.lower()
+
+        # Strip backend prefix first, then extract base name
+        stripped = strip_backend_prefix(model_name)
+
+        # Also strip org prefix for base name extraction (e.g., "NeverSleep/Lumimaid-v0.2-8B" -> "Lumimaid-v0.2-8B")
+        if "/" in stripped:
+            stripped = stripped.split("/")[-1]
+
+        base_name = get_base_model_name(stripped).lower()
+
+        if base_name not in base_name_index:
+            base_name_index[base_name] = []
+        if model_name_lower not in base_name_index[base_name]:
+            base_name_index[base_name].append(model_name_lower)
+
+    return base_name_index
+
+
+def _build_model_with_size_index(model_names: list[str]) -> dict[str, list[str]]:
+    """Build an index mapping model names (with size, without quant) to all matching names.
+
+    This enables aggregating stats across quantization variants only (e.g., Q4_K_M, Q8_0)
+    while keeping different sizes separate.
+
+    Unlike _build_base_name_index which groups ALL variants (including different sizes),
+    this index only groups quantization variants of the SAME sized model.
+
+    The key normalizes:
+    - Backend prefix (stripped for matching, but preserved in values)
+    - Org prefix (stripped for matching)
+    - Quantization suffix (stripped for matching)
+
+    But preserves:
+    - Size suffix (8B, 12B, etc.)
+
+    Args:
+        model_names: List of model names from API stats (may include backend prefixes
+            and quantization suffixes).
+
+    Returns:
+        Dictionary mapping normalized model names (backend/model-size) to lists of
+        original model names (lowercase) that match that model.
+
+    Example:
+        Input: ["koboldcpp/Lumimaid-v0.2-8B", "koboldcpp/Lumimaid-v0.2-8B-Q8_0",
+                "koboldcpp/Lumimaid-v0.2-12B", "aphrodite/NeverSleep/Lumimaid-v0.2-8B"]
+        Output: {
+            "koboldcpp/lumimaid-v0.2-8b": [
+                "koboldcpp/lumimaid-v0.2-8b",
+                "koboldcpp/lumimaid-v0.2-8b-q8_0"
+            ],
+            "koboldcpp/lumimaid-v0.2-12b": ["koboldcpp/lumimaid-v0.2-12b"],
+            "aphrodite/lumimaid-v0.2-8b": ["aphrodite/neversleep/lumimaid-v0.2-8b"]
+        }
+    """
+    model_with_size_index: dict[str, list[str]] = {}
+
+    for model_name in model_names:
+        model_name_lower = model_name.lower()
+
+        # Extract backend prefix if present
+        backend_prefix = ""
+        stripped = model_name_lower
+        if stripped.startswith("aphrodite/"):
+            backend_prefix = "aphrodite/"
+            stripped = stripped[len("aphrodite/") :]
+        elif stripped.startswith("koboldcpp/"):
+            backend_prefix = "koboldcpp/"
+            stripped = stripped[len("koboldcpp/") :]
+
+        # Strip org prefix (e.g., "neversleep/lumimaid-v0.2-8b" -> "lumimaid-v0.2-8b")
+        if "/" in stripped:
+            stripped = stripped.split("/")[-1]
+
+        # Strip quantization suffix
+        stripped_no_quant = _strip_quantization_suffix(stripped)
+
+        # Build key: backend_prefix + model_name (no org, no quant, but with size)
+        key = f"{backend_prefix}{stripped_no_quant}"
+
+        if key not in model_with_size_index:
+            model_with_size_index[key] = []
+        if model_name_lower not in model_with_size_index[key]:
+            model_with_size_index[key].append(model_name_lower)
+
+    return model_with_size_index
+
+
 class IndexedHordeModelStats(RootModel[_StatsLookup]):
     """Indexed model stats for O(1) lookups by model name.
 
     This wraps the stats response and provides case-insensitive dictionary access.
     Time complexity: O(1) for lookups instead of O(n) for dict iteration.
 
+    Two indexes are built:
+    - _base_name_index: Groups ALL variants (including different sizes) for group-level aggregation
+    - _model_with_size_index: Groups only quantization variants for per-model stats
+
     Usage:
         indexed = IndexedHordeModelStats(stats_response)
         day_count = indexed.get_day("model_name")      # Case-insensitive
@@ -249,6 +405,8 @@ class IndexedHordeModelStats(RootModel[_StatsLookup]):
     """
 
     root: _StatsLookup
+    _base_name_index: dict[str, list[str]] = {}
+    _model_with_size_index: dict[str, list[str]] = {}
 
     def __init__(self, stats_response: HordeModelStatsResponse) -> None:
         """Build indexed lookups from stats response.
@@ -264,6 +422,14 @@ class IndexedHordeModelStats(RootModel[_StatsLookup]):
         )
         super().__init__(root=lookups)
 
+        # Build indexes from all unique model names across all time periods
+        all_model_names = (
+            set(stats_response.day.keys()) | set(stats_response.month.keys()) | set(stats_response.total.keys())
+        )
+        model_names_list = list(all_model_names)
+        self._base_name_index = _build_base_name_index(model_names_list)
+        self._model_with_size_index = _build_model_with_size_index(model_names_list)
+
     def get_day(self, model_name: str) -> int | None:
         """Get day count for a model (case-insensitive). O(1)."""
         return self.root.day.get(model_name.lower())
@@ -282,12 +448,12 @@ class IndexedHordeModelStats(RootModel[_StatsLookup]):
         return name_lower in self.root.day or name_lower in self.root.month or name_lower in self.root.total
 
     def get_aggregated_stats(self, canonical_name: str) -> tuple[int, int, int]:
-        """Get aggregated stats across all backend variants of a model.
+        """Get aggregated stats across all backend variants and quantization versions of a model.
 
-        This method aggregates stats from all possible backend-prefixed variants:
-        - Canonical name (e.g., "ReadyArt/Broken-Tutu-24B")
-        - Aphrodite variant (e.g., "aphrodite/ReadyArt/Broken-Tutu-24B")
-        - KoboldCPP variant (e.g., "koboldcpp/Broken-Tutu-24B")
+        This method aggregates stats from:
+        - Exact name variants (canonical, aphrodite/, koboldcpp/ prefixed)
+        - All quantization variants sharing the same base model name (Q4_K_M, Q8_0, etc.)
+        - Different org-prefixed variants (e.g., "NeverSleep/Lumimaid" matches "Lumimaid")
 
         Args:
             canonical_name: The canonical model name from the model reference.
@@ -297,73 +463,136 @@ class IndexedHordeModelStats(RootModel[_StatsLookup]):
 
         Example:
             >>> indexed = IndexedHordeModelStats(stats_response)
-            >>> day, month, total = indexed.get_aggregated_stats("ReadyArt/Broken-Tutu-24B")
+            >>> day, month, total = indexed.get_aggregated_stats("Lumimaid-v0.2-8B")
+            # Will aggregate: Lumimaid-v0.2-8B, koboldcpp/Lumimaid-v0.2-8B,
+            #                 koboldcpp/Lumimaid-v0.2-8B-Q8_0, aphrodite/NeverSleep/Lumimaid-v0.2-8B, etc.
         """
+        from horde_model_reference.analytics.text_model_parser import get_base_model_name
         from horde_model_reference.meta_consts import get_model_name_variants
 
-        variants = get_model_name_variants(canonical_name)
+        # Collect all model names to aggregate (use set to avoid double-counting)
+        names_to_aggregate: set[str] = set()
 
+        # First, add exact variants from get_model_name_variants
+        variants = get_model_name_variants(canonical_name)
+        for variant in variants:
+            names_to_aggregate.add(variant.lower())
+
+        # Then, add all model names that share the same base model name
+        # This catches quantization variants and org-prefixed variants
+        # Strip org prefix from canonical name if present (e.g., "NeverSleep/Lumimaid-v0.2" -> "Lumimaid-v0.2")
+        canonical_without_org = canonical_name.split("/")[-1] if "/" in canonical_name else canonical_name
+        base_name = get_base_model_name(canonical_without_org).lower()
+        if base_name in self._base_name_index:
+            for api_model_name in self._base_name_index[base_name]:
+                names_to_aggregate.add(api_model_name)
+
+        # Aggregate stats across all matched names
         day_total = 0
         month_total = 0
         total_total = 0
 
-        for variant in variants:
-            day_total += self.get_day(variant) or 0
-            month_total += self.get_month(variant) or 0
-            total_total += self.get_total(variant) or 0
+        for name in names_to_aggregate:
+            day_total += self.get_day(name) or 0
+            month_total += self.get_month(name) or 0
+            total_total += self.get_total(name) or 0
 
         return (day_total, month_total, total_total)
 
     def get_stats_with_variations(
         self, canonical_name: str
     ) -> tuple[tuple[int, int, int], dict[str, tuple[int, int, int]]]:
-        """Get aggregated stats and individual backend variations.
+        """Get stats for a specific model broken down by backend.
 
-        This method returns both the aggregated stats (same as get_aggregated_stats)
-        and a dictionary of individual backend stats keyed by backend name.
+        Unlike get_aggregated_stats which aggregates across all models with the same
+        base name (e.g., all Lumimaid-v0.2 sizes), this method returns stats only for
+        the exact model specified (including its quantization variants), broken down
+        by backend prefix.
+
+        This enables showing per-model stats in the UI when displaying grouped models,
+        where each model variant (8B, 12B, etc.) shows its own stats by backend.
 
         Args:
             canonical_name: The canonical model name from the model reference.
 
         Returns:
             Tuple of (aggregated_stats, variations_dict) where:
-            - aggregated_stats: (day_total, month_total, total_total) aggregated
+            - aggregated_stats: (day_total, month_total, total_total) for this exact model
             - variations_dict: Dict of backend_name -> (day, month, total)
               Keys are 'canonical', 'aphrodite', 'koboldcpp' depending on what's found
         """
         from horde_model_reference.meta_consts import get_model_name_variants
 
+        # Collect all model names that are variants of this specific model
+        # Use _model_with_size_index to include quantization variants, but NOT size variants
+        names_to_aggregate: set[str] = set()
+
+        # Get exact backend-prefixed variants
         variants = get_model_name_variants(canonical_name)
-        variations: dict[str, tuple[int, int, int]] = {}
+        for variant in variants:
+            variant_lower = variant.lower()
+            names_to_aggregate.add(variant_lower)
+
+            # Build the normalized key to look up in _model_with_size_index
+            # The key format is: [backend_prefix/]model_name (no org, no quant)
+            backend_prefix = ""
+            stripped = variant_lower
+            if stripped.startswith("aphrodite/"):
+                backend_prefix = "aphrodite/"
+                stripped = stripped[len("aphrodite/") :]
+            elif stripped.startswith("koboldcpp/"):
+                backend_prefix = "koboldcpp/"
+                stripped = stripped[len("koboldcpp/") :]
+
+            # Strip org prefix if present
+            if "/" in stripped:
+                stripped = stripped.split("/")[-1]
+
+            # Strip quantization suffix and build key
+            stripped_no_quant = _strip_quantization_suffix(stripped)
+            key = f"{backend_prefix}{stripped_no_quant}"
+
+            if key in self._model_with_size_index:
+                for api_model_name in self._model_with_size_index[key]:
+                    names_to_aggregate.add(api_model_name)
+
+        # Track stats by backend for variations dict
+        backend_stats: dict[str, tuple[int, int, int]] = {
+            "canonical": (0, 0, 0),
+            "aphrodite": (0, 0, 0),
+            "koboldcpp": (0, 0, 0),
+        }
 
         day_total = 0
         month_total = 0
         total_total = 0
 
-        # Look up each variant and store by backend name
-        for variant in variants:
-            day = self.get_day(variant) or 0
-            month = self.get_month(variant) or 0
-            total = self.get_total(variant) or 0
+        # Look up each name and aggregate by backend
+        for name in names_to_aggregate:
+            day = self.get_day(name) or 0
+            month = self.get_month(name) or 0
+            total = self.get_total(name) or 0
 
-            # Only store if there's actual data
             if day > 0 or month > 0 or total > 0:
-                # Determine backend name from variant
-                if variant == canonical_name:
-                    backend_name = "canonical"
-                elif variant.startswith("aphrodite/"):
+                # Determine backend name from the model name
+                if name.startswith("aphrodite/"):
                     backend_name = "aphrodite"
-                elif variant.startswith("koboldcpp/"):
+                elif name.startswith("koboldcpp/"):
                     backend_name = "koboldcpp"
                 else:
-                    backend_name = "unknown"
+                    backend_name = "canonical"
 
-                variations[backend_name] = (day, month, total)
+                # Accumulate stats for this backend
+                prev_day, prev_month, prev_total = backend_stats[backend_name]
+                backend_stats[backend_name] = (prev_day + day, prev_month + month, prev_total + total)
 
             day_total += day
             month_total += month
             total_total += total
 
+        # Filter to only backends with data
+        variations = {k: v for k, v in backend_stats.items() if v != (0, 0, 0)}
+
         return (day_total, month_total, total_total), variations
 
 

{horde_model_reference-2.1.0 → horde_model_reference-2.1.2/src/horde_model_reference.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: horde_model_reference
-Version: 2.1.0
+Version: 2.1.2
 Summary: A helper library providing a way to work with the lists of generation models, utility models, and any other related files required for the AI-Horde ecosystem.
 Author-email: tazlin <tazlin.on.github@gmail.com>, db0 <mail@dbzer0.com>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE

{horde_model_reference-2.1.0 → horde_model_reference-2.1.2}/src/horde_model_reference.egg-info/SOURCES.txt

@@ -187,6 +187,7 @@ tests/horde_api/test_data_merger.py
 tests/horde_api/test_horde_api_integration.py
 tests/horde_api/test_horde_api_integration_live.py
 tests/horde_api/test_indexed_horde_types.py
+tests/integrations/test_stats_aggregation.py
 tests/service/__init__.py
 tests/service/test_replica_backend_base.py
 tests/service/test_v1_api.py

horde_model_reference-2.1.2/tests/integrations/test_stats_aggregation.py

@@ -0,0 +1,247 @@
+"""Tests for stats aggregation across quantization variants."""
+
+from __future__ import annotations
+
+from horde_model_reference.integrations.horde_api_models import (
+    HordeModelStatsResponse,
+    IndexedHordeModelStats,
+)
+
+
+class TestIndexedHordeModelStatsAggregation:
+    """Test suite for stats aggregation with quantization variants."""
+
+    def test_aggregate_stats_with_quantization_variants(self) -> None:
+        """Test that stats aggregate correctly across quantization variants."""
+        stats = HordeModelStatsResponse(
+            day={
+                "koboldcpp/Lumimaid-v0.2-8B": 4080,
+                "koboldcpp/Lumimaid-v0.2-8B-Q8_0": 1500,
+                "koboldcpp/Lumimaid-v0.2-8B-Q4_K_M": 800,
+            },
+            month={
+                "koboldcpp/Lumimaid-v0.2-8B": 40000,
+                "koboldcpp/Lumimaid-v0.2-8B-Q8_0": 15000,
+                "koboldcpp/Lumimaid-v0.2-8B-Q4_K_M": 8000,
+            },
+            total={
+                "koboldcpp/Lumimaid-v0.2-8B": 400000,
+                "koboldcpp/Lumimaid-v0.2-8B-Q8_0": 150000,
+                "koboldcpp/Lumimaid-v0.2-8B-Q4_K_M": 80000,
+            },
+        )
+
+        indexed = IndexedHordeModelStats(stats)
+        day, month, total = indexed.get_aggregated_stats("Lumimaid-v0.2-8B")
+
+        # Should aggregate all quantization variants
+        assert day == 4080 + 1500 + 800
+        assert month == 40000 + 15000 + 8000
+        assert total == 400000 + 150000 + 80000
+
+    def test_aggregate_stats_with_org_prefix_variants(self) -> None:
+        """Test that stats aggregate across org-prefixed variants."""
+        stats = HordeModelStatsResponse(
+            day={
+                "Lumimaid-v0.2-8B": 1000,
+                "aphrodite/NeverSleep/Lumimaid-v0.2-8B": 2000,
+                "koboldcpp/Lumimaid-v0.2-8B": 3000,
+            },
+            month={},
+            total={},
+        )
+
+        indexed = IndexedHordeModelStats(stats)
+        day, _month, _total = indexed.get_aggregated_stats("Lumimaid-v0.2-8B")
+
+        # Should aggregate across all prefixes
+        assert day == 1000 + 2000 + 3000
+
+    def test_aggregate_stats_with_all_variants(self) -> None:
+        """Test that stats aggregate across backend, org, and quantization variants."""
+        stats = HordeModelStatsResponse(
+            day={
+                "Lumimaid-v0.2-8B": 100,
+                "aphrodite/Lumimaid-v0.2-8B": 200,
+                "aphrodite/NeverSleep/Lumimaid-v0.2-8B": 300,
+                "koboldcpp/Lumimaid-v0.2-8B": 400,
+                "koboldcpp/Lumimaid-v0.2-8B-Q8_0": 500,
+                "koboldcpp/Lumimaid-v0.2-8B-Q4_K_M": 600,
+            },
+            month={
+                "Lumimaid-v0.2-8B": 1000,
+                "aphrodite/NeverSleep/Lumimaid-v0.2-8B": 3000,
+            },
+            total={},
+        )
+
+        indexed = IndexedHordeModelStats(stats)
+        day, month, _total = indexed.get_aggregated_stats("Lumimaid-v0.2-8B")
+
+        assert day == 100 + 200 + 300 + 400 + 500 + 600
+        assert month == 1000 + 3000
+
+    def test_get_stats_with_variations_backend_breakdown(self) -> None:
+        """Test that variations are correctly grouped by backend."""
+        stats = HordeModelStatsResponse(
+            day={
+                "Lumimaid-v0.2-8B": 100,
+                "aphrodite/NeverSleep/Lumimaid-v0.2-8B": 200,
+                "koboldcpp/Lumimaid-v0.2-8B": 300,
+                "koboldcpp/Lumimaid-v0.2-8B-Q8_0": 400,
+            },
+            month={},
+            total={},
+        )
+
+        indexed = IndexedHordeModelStats(stats)
+        (day_total, _month, _total), variations = indexed.get_stats_with_variations("Lumimaid-v0.2-8B")
+
+        assert day_total == 100 + 200 + 300 + 400
+        assert "canonical" in variations
+        assert "aphrodite" in variations
+        assert "koboldcpp" in variations
+        assert variations["canonical"][0] == 100
+        assert variations["aphrodite"][0] == 200
+        assert variations["koboldcpp"][0] == 300 + 400  # Aggregates quant variants
+
+    def test_aggregate_stats_different_base_models_not_mixed(self) -> None:
+        """Test that different base models are not incorrectly aggregated."""
+        stats = HordeModelStatsResponse(
+            day={
+                "Lumimaid-v0.2-8B": 100,
+                "Lumimaid-v0.2-8B-Q8_0": 200,
+                "Llama-3-8B": 1000,
+                "Llama-3-8B-Q4_K_M": 2000,
+            },
+            month={},
+            total={},
+        )
+
+        indexed = IndexedHordeModelStats(stats)
+
+        lumimaid_day, _m, _t = indexed.get_aggregated_stats("Lumimaid-v0.2-8B")
+        llama_day, _m, _t = indexed.get_aggregated_stats("Llama-3-8B")
+
+        # Each base model should only aggregate its own variants
+        assert lumimaid_day == 100 + 200
+        assert llama_day == 1000 + 2000
+
+    def test_aggregate_stats_case_insensitive(self) -> None:
+        """Test that aggregation is case-insensitive."""
+        stats = HordeModelStatsResponse(
+            day={
+                "KOBOLDCPP/Lumimaid-v0.2-8B": 100,
+                "koboldcpp/lumimaid-v0.2-8b-q8_0": 200,
+            },
+            month={},
+            total={},
+        )
+
+        indexed = IndexedHordeModelStats(stats)
+        day, _m, _t = indexed.get_aggregated_stats("Lumimaid-v0.2-8B")
+
+        assert day == 100 + 200
+
+    def test_aggregate_stats_no_duplicates(self) -> None:
+        """Test that stats are not double-counted when exact match exists."""
+        stats = HordeModelStatsResponse(
+            day={
+                "Lumimaid-v0.2-8B": 100,  # Exact match and base name match
+            },
+            month={},
+            total={},
+        )
+
+        indexed = IndexedHordeModelStats(stats)
+        day, _m, _t = indexed.get_aggregated_stats("Lumimaid-v0.2-8B")
+
+        # Should only count once, not twice
+        assert day == 100
+
+    def test_aggregate_stats_empty_response(self) -> None:
+        """Test aggregation with empty stats response."""
+        stats = HordeModelStatsResponse(day={}, month={}, total={})
+
+        indexed = IndexedHordeModelStats(stats)
+        day, month, total = indexed.get_aggregated_stats("Lumimaid-v0.2-8B")
+
+        assert day == 0
+        assert month == 0
+        assert total == 0
+
+    def test_aggregate_stats_model_not_found(self) -> None:
+        """Test aggregation when model doesn't exist in stats."""
+        stats = HordeModelStatsResponse(
+            day={"SomeOtherModel": 100},
+            month={},
+            total={},
+        )
+
+        indexed = IndexedHordeModelStats(stats)
+        day, month, total = indexed.get_aggregated_stats("Lumimaid-v0.2-8B")
+
+        assert day == 0
+        assert month == 0
+        assert total == 0
+
+    def test_aggregate_stats_canonical_name_with_org_prefix(self) -> None:
+        """Test that canonical names with org prefix correctly match API stats.
+
+        This is a critical test case because model reference entries often have
+        org prefixes (e.g., "NeverSleep/Lumimaid-v0.2") but API stats may have
+        different prefixing patterns.
+        """
+        stats = HordeModelStatsResponse(
+            day={
+                "koboldcpp/Lumimaid-v0.2-8B": 4080,
+                "koboldcpp/Lumimaid-v0.2-8B-Q8_0": 1500,
+                "aphrodite/NeverSleep/Lumimaid-v0.2-8B": 2000,
+            },
+            month={
+                "koboldcpp/Lumimaid-v0.2-8B": 40000,
+                "koboldcpp/Lumimaid-v0.2-8B-Q8_0": 15000,
+                "aphrodite/NeverSleep/Lumimaid-v0.2-8B": 20000,
+            },
+            total={},
+        )
+
+        indexed = IndexedHordeModelStats(stats)
+
+        # Query with canonical name that HAS org prefix (like in model reference)
+        canonical_with_org = "NeverSleep/Lumimaid-v0.2"
+        day, month, _total = indexed.get_aggregated_stats(canonical_with_org)
+
+        # Should aggregate all variants even though canonical has org prefix
+        assert day == 4080 + 1500 + 2000
+        assert month == 40000 + 15000 + 20000
+
+    def test_get_stats_with_variations_canonical_with_org_prefix(self) -> None:
+        """Test variations breakdown with canonical name that has org prefix.
+
+        When querying for a specific model like 'NeverSleep/Lumimaid-v0.2-8B',
+        get_stats_with_variations should find:
+        - The aphrodite variant: aphrodite/NeverSleep/Lumimaid-v0.2-8B
+        - The koboldcpp variant: koboldcpp/Lumimaid-v0.2-8B
+        - Quantization variants: koboldcpp/Lumimaid-v0.2-8B-Q8_0
+        """
+        stats = HordeModelStatsResponse(
+            day={
+                "koboldcpp/Lumimaid-v0.2-8B": 300,
+                "koboldcpp/Lumimaid-v0.2-8B-Q8_0": 400,
+                "aphrodite/NeverSleep/Lumimaid-v0.2-8B": 200,
+            },
+            month={},
+            total={},
+        )
+
+        indexed = IndexedHordeModelStats(stats)
+
+        # Query with canonical name that HAS org prefix (like in model reference)
+        (day_total, _m, _t), variations = indexed.get_stats_with_variations("NeverSleep/Lumimaid-v0.2-8B")
+
+        assert day_total == 300 + 400 + 200
+        assert "aphrodite" in variations
+        assert "koboldcpp" in variations
+        assert variations["aphrodite"][0] == 200
+        assert variations["koboldcpp"][0] == 300 + 400