Download apps/core/config/notifications.py from jun2024/fc: direct link, hf CLI and curl.
- Browser
- Download file 5.97 kB
-
https://huggingface.co/spaces/jun2024/fc/resolve/main/apps/core/config/notifications.py
- Command line
-
hf download hf://spaces/jun2024/fc/apps/core/config/notifications.py
-
curl -L -o notifications.py https://huggingface.co/spaces/jun2024/fc/resolve/main/apps/core/config/notifications.py
5.97 kB
| """Module for notifications.""" | |
| from __future__ import annotations | |
| import logging | |
| import threading | |
| import time | |
| from abc import ABC, abstractmethod | |
| from dataclasses import dataclass, field | |
| from typing import Any | |
| logger = logging.getLogger(__name__) | |
| class ConfigChangeListener(ABC): | |
| def on_config_changed(self, key: str, old_value: Any, new_value: Any) -> None: ... | |
| def on_config_added(self, key: str, value: Any) -> None: ... | |
| def on_config_removed(self, key: str, old_value: Any) -> None: ... | |
| def on_config_reloaded(self) -> None: ... | |
| class ConfigChangeEvent: | |
| key: str | |
| old_value: Any | |
| new_value: Any | |
| change_type: str | |
| timestamp: float = field(default_factory=time.time) | |
| class ConfigNotificationManager: | |
| def __init__(self) -> None: | |
| self._listeners: list[ConfigChangeListener] = [] | |
| self._key_listeners: dict[str, list[ConfigChangeListener]] = {} | |
| self._prefix_listeners: dict[str, list[ConfigChangeListener]] = {} | |
| self._event_history: list[ConfigChangeEvent] = [] | |
| self._max_history = 100 | |
| self._lock = threading.Lock() | |
| def add_listener( | |
| self, listener: ConfigChangeListener, key_filter: str | None = None, prefix_filter: str | None = None | |
| ) -> None: | |
| with self._lock: | |
| if key_filter: | |
| self._key_listeners.setdefault(key_filter, []) | |
| if listener not in self._key_listeners[key_filter]: | |
| self._key_listeners[key_filter].append(listener) | |
| elif prefix_filter: | |
| self._prefix_listeners.setdefault(prefix_filter, []) | |
| if listener not in self._prefix_listeners[prefix_filter]: | |
| self._prefix_listeners[prefix_filter].append(listener) | |
| else: | |
| if listener not in self._listeners: | |
| self._listeners.append(listener) | |
| def remove_listener(self, listener: ConfigChangeListener) -> None: | |
| with self._lock: | |
| if listener in self._listeners: | |
| self._listeners.remove(listener) | |
| for key_listeners in self._key_listeners.values(): | |
| if listener in key_listeners: | |
| key_listeners.remove(listener) | |
| for prefix_listeners in self._prefix_listeners.values(): | |
| if listener in prefix_listeners: | |
| prefix_listeners.remove(listener) | |
| def notify_change(self, key: str, old_value: Any, new_value: Any) -> None: | |
| change_type = self._determine_change_type(old_value, new_value) | |
| event = ConfigChangeEvent(key, old_value, new_value, change_type) | |
| with self._lock: | |
| self._event_history.append(event) | |
| if len(self._event_history) > self._max_history: | |
| self._event_history.pop(0) | |
| listeners_to_notify = self._collect_listeners(key) | |
| for listener in listeners_to_notify: | |
| self._dispatch_to_listener(listener, change_type, key, old_value, new_value) | |
| def _determine_change_type(old_value: Any, new_value: Any) -> str: | |
| if old_value is None and new_value is not None: | |
| return "added" | |
| if old_value is not None and new_value is None: | |
| return "removed" | |
| return "modified" | |
| def _collect_listeners(self, key: str) -> set[Any]: | |
| listeners: set[ConfigChangeListener] = set() | |
| listeners.update(self._listeners) | |
| if key in self._key_listeners: | |
| listeners.update(self._key_listeners[key]) | |
| for prefix, prefix_listeners in self._prefix_listeners.items(): | |
| if key.startswith(prefix): | |
| listeners.update(prefix_listeners) | |
| return listeners | |
| def _dispatch_to_listener(listener: Any, change_type: str, key: str, old_value: Any, new_value: Any) -> None: | |
| try: | |
| if change_type == "added" and hasattr(listener, "on_config_added"): | |
| listener.on_config_added(key, new_value) | |
| elif change_type == "removed" and hasattr(listener, "on_config_removed"): | |
| listener.on_config_removed(key, old_value) | |
| else: | |
| listener.on_config_changed(key, old_value, new_value) | |
| except Exception as e: | |
| logger.error(f"配置变更通知失败 (key={key}, listener={listener.__class__.__name__}): {e}") | |
| def notify_reload(self) -> None: | |
| with self._lock: | |
| listeners_to_notify: list[ConfigChangeListener] = list(self._listeners) | |
| for key_listeners in self._key_listeners.values(): | |
| listeners_to_notify.extend(key_listeners) | |
| for prefix_listeners in self._prefix_listeners.values(): | |
| listeners_to_notify.extend(prefix_listeners) | |
| for listener in set(listeners_to_notify): | |
| try: | |
| if hasattr(listener, "on_config_reloaded"): | |
| listener.on_config_reloaded() | |
| except Exception as e: | |
| logger.error(f"配置重载通知失败 (listener={listener.__class__.__name__}): {e}") | |
| def get_event_history(self, limit: int | None = None) -> list[ConfigChangeEvent]: | |
| with self._lock: | |
| events = self._event_history.copy() | |
| if limit: | |
| events = events[-limit:] | |
| return events | |
| def clear_history(self) -> None: | |
| with self._lock: | |
| self._event_history.clear() | |
| def get_listener_count(self) -> dict[str, int]: | |
| with self._lock: | |
| return { | |
| "global": len(self._listeners), | |
| "key_specific": sum(len(listeners) for listeners in self._key_listeners.values()), | |
| "prefix_specific": sum(len(listeners) for listeners in self._prefix_listeners.values()), | |
| "total_keys": len(self._key_listeners), | |
| "total_prefixes": len(self._prefix_listeners), | |
| } | |