| """A store that remembers slow-changing reads (classes, members, roles, tests, assignments) for a short time. |
| |
| Any change made through it to one of those forgets everything remembered at once. Rows come back as copies. |
| """ |
| from __future__ import annotations |
|
|
| import copy |
| import threading |
| import time |
|
|
| READS = frozenset({ |
| "classes", "classes_of_student", "classes_taught", "members", "get_class", "roles_of", |
| "tests_of_classes", "get_test", "assignments_of_classes", "get_assignment", "all_students", "accounts", "curriculum", |
| "subjects", |
| }) |
| CHANGES = frozenset({ |
| "create_class", "update_class", "delete_class", "add_member", "remove_member", "give_role", "take_role", "link_user", |
| "create_test", "update_test", "remove_test", "create_assignment", "remove_assignment", "set_lesson_dates", |
| "create_subject", "update_subject", "delete_subject", "create_lesson", "save_lesson", "delete_lesson", |
| }) |
|
|
|
|
| def _key(name: str, args: tuple, kwargs: dict): |
| def freeze(v): |
| if isinstance(v, (set, frozenset)): |
| return tuple(sorted(v, key=repr)) |
| if isinstance(v, (list, tuple)): |
| return tuple(freeze(x) for x in v) |
| return v |
| return name, freeze(args), tuple(sorted((k, freeze(v)) for k, v in kwargs.items())) |
|
|
|
|
| class CachedStore: |
| def __init__(self, store, seconds: float, clock=time.monotonic) -> None: |
| self._store, self._seconds, self._clock = store, seconds, clock |
| self._lock = threading.Lock() |
| self._kept: dict = {} |
| self._generation = 0 |
|
|
| def forget(self) -> None: |
| with self._lock: |
| self._kept.clear() |
| self._generation += 1 |
|
|
| def __getattr__(self, name: str): |
| target = getattr(self._store, name) |
| if self._seconds <= 0 or not callable(target): |
| return target |
| if name in CHANGES: |
| def change(*args, **kwargs): |
| try: |
| return target(*args, **kwargs) |
| finally: |
| self.forget() |
| return change |
| if name in READS: |
| def read(*args, **kwargs): |
| key = _key(name, args, kwargs) |
| now = self._clock() |
| with self._lock: |
| hit = self._kept.get(key) |
| if hit and hit[0] > now: |
| return copy.deepcopy(hit[1]) |
| generation = self._generation |
| value = target(*args, **kwargs) |
| with self._lock: |
| if generation == self._generation: |
| self._kept[key] = (now + self._seconds, copy.deepcopy(value)) |
| return value |
| return read |
| return target |
|
|
