Можно ли предотвратить чтение из замороженного класса данных Python?

Я согласен с Джоном в том, что ведение надлежащей инвентаризации ваших данных и обновление общих экземпляров было бы лучшим способом решения проблемы, но если это невозможно или неосуществимо по какой-либо причине (вам следует серьезно изучить, есть ли это действительно достаточно важно), есть способ добиться того, что вы описали (кстати, хороший макет). Однако для этого потребуется немного нетривиального кода, и впоследствии на ваш класс данных будут накладываться некоторые ограничения:

from dataclasses import dataclass, replace, field
from typing import Any, ClassVar


@dataclass(frozen=True)
class AlwaysFreshData:
    #: sentinel that is used to mark stale instances
    STALE: ClassVar = object()

    fresh_data: str
    #: private staleness indicator for this instance
    _freshness: Any = field(default=None, repr=False)

    def __post_init__(self):
        """Updates a donor instance to be stale now."""

        if self._freshness is None:
            # is a fresh instance
            pass
        elif self._freshness is self.STALE:
            # this case probably leads to inconsistent data, maybe raise an error?
            print(f'Warning: Building new {type(self)} instance from stale data - '
                  f'is that really what you want?')
        elif isinstance(self._freshnes, type(self)):
            # is a fresh instance from an older, now stale instance
            object.__setattr__(self._freshness, '_instance_freshness', self.STALE)
        else:
            raise ValueError("Don't mess with private attributes!")
        object.__setattr__(self, '_instance_freshness', self)

    def __getattribute__(self, name):
        if object.__getattribute__(self, '_instance_freshness') is self.STALE:
            raise RuntimeError('Instance went stale!')
        return object.__getattribute__(self, name)

Что будет вести себя так для вашего тестового кода:

# basic functionality
>>> original = AlwaysFreshData(fresh_data="fresh")
>>> original.fresh_data
fresh
>>> new = replace(original, fresh_data="even fresher")
>>> new.fresh_data
even_fresher

# if fresher data was used, the old instance is "disabled"
>>> original.fresh_data
Traceback (most recent call last):
  File [...] in __getattribute__
    raise RuntimeError('Instance went stale!')
RuntimeError: Instance went stale!

# defining a new, unrelated instance doesn't mess with existing ones
>>> runner_up = AlwaysFreshData(fresh_data="different freshness")
>>> runner_up.fresh_data
different freshness
>>> new.fresh_data  # still fresh
even_fresher
>>> original.fresh_data  # still stale
Traceback (most recent call last):
  File [...] in __getattribute__
    raise RuntimeError('Instance went stale!')
RuntimeError: Instance went stale!

Важно отметить, что этот подход вводит новое поле в класс данных, а именно _freshness, которое потенциально может быть установлено вручную и испортит всю логику. Вы можете попытаться отловить его в __post_init__, но что-то вроде этого было бы действенным хитрым способом сохранить свежий экземпляр старого экземпляра:

>>> original = AlwaysFreshData(fresh_data="fresh")
# calling replace with _freshness=None is a no-no, but we can't prohibit it
>>> new = replace(original, fresh_data="even fresher", _freshness=None)
>>> original.fresh_data
fresh
>>> new.fresh_data
even_fresher

Кроме того, нам нужно значение по умолчанию для него, что означает, что любые поля, объявленные ниже, также нуждаются в значении по умолчанию (что неплохо - просто объявите эти поля над ним), включая все поля от будущих дочерних элементов (это больше проблема, и есть огромный пост о том, как справиться с таким сценарием).

Вам также понадобится доступное значение дозорного, когда вы используете этот тип шаблона. Это неплохо, но некоторым людям это может показаться странным.