alphard/ComfyUI-Lora-Manager
1
0
Fork 0
mirror of https://github.com/willmiao/ComfyUI-Lora-Manager.git synced 2026-03-21 21:22:11 -03:00
Code Issues Packages Projects Releases Wiki Activity

feat(early-access): implement EA filtering and UI improvements

Browse Source 
Add Early Access version support with filtering and improved UI:

Backend:
- Add is_early_access and early_access_ends_at fields to ModelVersionRecord
- Implement two-phase EA detection (bulk API + single API enrichment)
- Add hide_early_access_updates setting to filter EA updates
- Update has_update() and has_updates_bulk() to respect EA filter setting
- Add _enrich_early_access_details() for precise EA time fetching
- Fix setting propagation through base_model_service and model_update_service

Frontend:
- Add smart relative time display for EA (in Xh, in Xd, or date)
- Replace EA label with clock icon in metadata (fa-clock)
- Show Download button with bolt icon for EA versions (fa-bolt)
- Change EA badge color to #F59F00 (CivitAI Buzz theme)
- Fix toggle UI for hide_early_access_updates setting
- Add translation keys for EA time formatting

Tests:
- Update all tests to pass with new EA functionality
- Add test coverage for EA filtering logic

Closes #815
This commit is contained in:
Will Miao
2026-02-20 10:32:51 +08:00
parent e8b37365a6
commit 67869f19ff
22 changed files with 506 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
py/services/base_model_service.py
View File

@@ -380,6 +380,13 @@ class BaseModelService(ABC):
strategy = "same_base"
same_base_mode = strategy == "same_base"
# Check user setting for hiding early access updates
hide_early_access = False
try:
hide_early_access = bool(self.settings.get("hide_early_access_updates", False))
except Exception:
hide_early_access = False
records = None
resolved: Optional[Dict[int, bool]] = None
if same_base_mode:
@@ -388,7 +395,7 @@ class BaseModelService(ABC):
try:
records = await record_method(self.model_type, ordered_ids)
resolved = {
model_id: record.has_update()
model_id: record.has_update(hide_early_access=hide_early_access)
for model_id, record in records.items()
}
except Exception as exc:
@@ -406,7 +413,7 @@ class BaseModelService(ABC):
bulk_method = getattr(self.update_service, "has_updates_bulk", None)
if callable(bulk_method):
try:
resolved = await bulk_method(self.model_type, ordered_ids)
resolved = await bulk_method(self.model_type, ordered_ids, hide_early_access=hide_early_access)
except Exception as exc:
logger.error(
"Failed to resolve update status in bulk for %s models (%s): %s",
@@ -419,7 +426,7 @@ class BaseModelService(ABC):
if resolved is None:
tasks = [
self.update_service.has_update(self.model_type, model_id)
self.update_service.has_update(self.model_type, model_id, hide_early_access=hide_early_access)
for model_id in ordered_ids
]
results = await asyncio.gather(*tasks, return_exceptions=True)
@@ -457,6 +464,7 @@ class BaseModelService(ABC):
flag = record.has_update_for_base(
threshold_version,
base_model,
hide_early_access=hide_early_access,
)
else:
flag = default_flag

101
py/services/model_update_service.py
View File

@@ -7,7 +7,8 @@ import os
import sqlite3
import time
from dataclasses import dataclass, replace
from typing import Dict, Iterable, List, Mapping, Optional, Sequence
from datetime import datetime, timezone
from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence
from .errors import RateLimitError, ResourceNotFoundError
from .settings_manager import get_settings_manager
@@ -64,7 +65,9 @@ class ModelVersionRecord:
preview_url: Optional[str]
is_in_library: bool
should_ignore: bool
early_access_ends_at: Optional[str] = None
sort_index: int = 0
is_early_access: bool = False
@dataclass
@@ -97,8 +100,12 @@ class ModelUpdateRecord:
return [version.version_id for version in self.versions if version.is_in_library]
def has_update(self) -> bool:
"""Return True when a non-ignored remote version newer than the newest local copy is available."""
def has_update(self, hide_early_access: bool = False) -> bool:
"""Return True when a non-ignored remote version newer than the newest local copy is available.
Args:
hide_early_access: If True, exclude early access versions from update check.
"""
if self.should_ignore_model:
return False
@@ -110,22 +117,56 @@ class ModelUpdateRecord:
if max_in_library is None:
return any(
not version.is_in_library and not version.should_ignore for version in self.versions
not version.is_in_library
and not version.should_ignore
and not (hide_early_access and ModelUpdateRecord._is_early_access_active(version))
for version in self.versions
)
for version in self.versions:
if version.is_in_library or version.should_ignore:
continue
if hide_early_access and ModelUpdateRecord._is_early_access_active(version):
continue
if version.version_id > max_in_library:
return True
return False
@staticmethod
def _is_early_access_active(version: ModelVersionRecord) -> bool:
"""Check if a version is currently in early access period.
Uses two-phase detection:
1. If exact EA end time available (from single version API), use it for precise check
2. Otherwise fallback to basic EA flag (from bulk API)
"""
# Phase 2: Precise check with exact end time
if version.early_access_ends_at:
try:
ea_date = datetime.fromisoformat(
version.early_access_ends_at.replace("Z", "+00:00")
)
return ea_date > datetime.now(timezone.utc)
except (ValueError, AttributeError):
# If date parsing fails, treat as active EA (conservative)
return True
# Phase 1: Basic EA flag from bulk API
return version.is_early_access
def has_update_for_base(
self,
local_version_id: Optional[int],
local_base_model: Optional[str],
hide_early_access: bool = False,
) -> bool:
"""Return True when a newer remote version with the same base model exists."""
"""Return True when a newer remote version with the same base model exists.
Args:
local_version_id: The current local version id.
local_base_model: The base model to filter by.
hide_early_access: If True, exclude early access versions from update check.
"""
if self.should_ignore_model:
return False
@@ -153,6 +194,8 @@ class ModelUpdateRecord:
for version in self.versions:
if version.is_in_library or version.should_ignore:
continue
if hide_early_access and ModelUpdateRecord._is_early_access_active(version):
continue
version_base = _normalize_base_model(version.base_model)
if version_base != normalized_base:
continue
@@ -268,6 +311,14 @@ class ModelUpdateService:
"ALTER TABLE model_update_versions "
"ADD COLUMN should_ignore INTEGER NOT NULL DEFAULT 0"
),
"early_access_ends_at": (
"ALTER TABLE model_update_versions "
"ADD COLUMN early_access_ends_at TEXT"
),
"is_early_access": (
"ALTER TABLE model_update_versions "
"ADD COLUMN is_early_access INTEGER NOT NULL DEFAULT 0"
),
}
for column, statement in migrations.items():
@@ -367,6 +418,8 @@ class ModelUpdateService:
preview_url TEXT,
is_in_library INTEGER NOT NULL DEFAULT 0,
should_ignore INTEGER NOT NULL DEFAULT 0,
early_access_ends_at TEXT,
is_early_access INTEGER NOT NULL DEFAULT 0,
PRIMARY KEY (model_id, version_id),
FOREIGN KEY(model_id) REFERENCES model_update_status(model_id) ON DELETE CASCADE
)
@@ -384,6 +437,8 @@ class ModelUpdateService:
"preview_url",
"is_in_library",
"should_ignore",
"early_access_ends_at",
"is_early_access",
]
defaults = {
"sort_index": "0",
@@ -394,6 +449,8 @@ class ModelUpdateService:
"preview_url": "NULL",
"is_in_library": "0",
"should_ignore": "0",
"early_access_ends_at": "NULL",
"is_early_access": "0",
}
select_parts = []
@@ -667,6 +724,8 @@ class ModelUpdateService:
is_in_library=False,
should_ignore=should_ignore,
sort_index=len(versions),
early_access_ends_at=None,
is_early_access=False,
)
)
@@ -686,16 +745,17 @@ class ModelUpdateService:
async with self._lock:
return self._get_record(model_type, model_id)
async def has_update(self, model_type: str, model_id: int) -> bool:
async def has_update(self, model_type: str, model_id: int, hide_early_access: bool = False) -> bool:
"""Determine if a model has updates pending."""
record = await self.get_record(model_type, model_id)
return record.has_update() if record else False
return record.has_update(hide_early_access=hide_early_access) if record else False
async def has_updates_bulk(
self,
model_type: str,
model_ids: Sequence[int],
hide_early_access: bool = False,
) -> Dict[int, bool]:
"""Return update availability for each model id in a single database pass."""
@@ -707,7 +767,7 @@ class ModelUpdateService:
records = self._get_records_bulk(model_type, normalized_ids)
return {
model_id: records.get(model_id).has_update() if records.get(model_id) else False
model_id: records.get(model_id).has_update(hide_early_access=hide_early_access) if records.get(model_id) else False
for model_id in normalized_ids
}
@@ -987,6 +1047,8 @@ class ModelUpdateService:
is_in_library=True,
should_ignore=ignore_map.get(missing_id, False),
sort_index=len(versions),
early_access_ends_at=None,
is_early_access=False,
)
)
@@ -1029,6 +1091,8 @@ class ModelUpdateService:
is_in_library=version_id in local_set,
should_ignore=ignore_map.get(version_id, remote_version.should_ignore),
sort_index=sort_map.get(version_id, index),
early_access_ends_at=remote_version.early_access_ends_at,
is_early_access=remote_version.is_early_access,
)
)
@@ -1055,6 +1119,8 @@ class ModelUpdateService:
is_in_library=True,
should_ignore=ignore_map.get(version_id, False),
sort_index=len(versions),
early_access_ends_at=None,
is_early_access=False,
)
)
@@ -1120,6 +1186,11 @@ class ModelUpdateService:
released_at = _normalize_string(entry.get("publishedAt") or entry.get("createdAt"))
size_bytes = self._extract_size_bytes(entry.get("files"))
preview_url = self._extract_preview_url(entry.get("images"))
early_access_ends_at = _normalize_string(entry.get("earlyAccessEndsAt"))
# Check availability field from bulk API for basic EA detection
availability = _normalize_string(entry.get("availability"))
is_early_access = availability == "EarlyAccess"
return ModelVersionRecord(
version_id=version_id,
@@ -1130,7 +1201,9 @@ class ModelUpdateService:
preview_url=preview_url,
is_in_library=False,
should_ignore=False,
early_access_ends_at=early_access_ends_at,
sort_index=index,
is_early_access=is_early_access,
)
def _extract_size_bytes(self, files) -> Optional[int]:
@@ -1231,7 +1304,8 @@ class ModelUpdateService:
version_rows = conn.execute(
f"""
SELECT model_id, version_id, sort_index, name, base_model, released_at,
size_bytes, preview_url, is_in_library, should_ignore
size_bytes, preview_url, is_in_library, should_ignore, early_access_ends_at,
is_early_access
FROM model_update_versions
WHERE model_id IN ({placeholders})
ORDER BY model_id ASC, sort_index ASC, version_id ASC
@@ -1252,7 +1326,9 @@ class ModelUpdateService:
preview_url=row["preview_url"],
is_in_library=bool(row["is_in_library"]),
should_ignore=bool(row["should_ignore"]),
early_access_ends_at=row["early_access_ends_at"],
sort_index=_normalize_int(row["sort_index"]) or 0,
is_early_access=bool(row["is_early_access"]),
)
)
@@ -1308,8 +1384,9 @@ class ModelUpdateService:
"""
INSERT INTO model_update_versions (
version_id, model_id, sort_index, name, base_model, released_at,
size_bytes, preview_url, is_in_library, should_ignore
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
size_bytes, preview_url, is_in_library, should_ignore, early_access_ends_at,
is_early_access
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
""",
(
version.version_id,
@@ -1322,6 +1399,8 @@ class ModelUpdateService:
version.preview_url,
1 if version.is_in_library else 0,
1 if version.should_ignore else 0,
version.early_access_ends_at,
1 if version.is_early_access else 0,
),
)
conn.commit()