The following is a contrived example of a potential code smell
that I’ve repeatedly encountered when implementing a GUI with which instances of a class created by letting the user fill out a form. The question is if the pattern I use is correct, or if there is a better way.

The app’s core logic contains a class Data that is initialized with
a Dict (among other things):

class Data:
    def __init__(self, stuff: Dict, *args, **kwargs) -> None:
        self.stuff = stuff
        # ...

The attribute self.things is read-only. Note that __init__ has other arguments,
which are used to set other attributes of Data.

The main use-case is that raw is read from a .json file:

with open(path, 'r') as f:
    raw = f.read()
stuff = json.loads(raw)
data = Data(stuff, ...)

Instances of Data may be created using a UI form,
in which the user enters a filesystem path (from which raw is read)
and the other parameters of __init__.
The instances should also be managed by the app’s UI; when the app is closed, the
Data instances should be serialized, saved, and later loaded again.
Out of the potentially very large database of Data objects,
only very few are required at the same time.

To prevent massive data duplication (let’s say the file at path is
very large, and potentially used by many Data objects) and to allow
editing the Data instances by changing the path that the raw
parameter is read from, the file path should be saved, not the data
itself.

This means that the Data instances themselves cannot be serialized.
Instead, I’ve opted to use an intermediate class

class DataInfo:
    def __init__(self, path: str, *args, **kwargs) -> None:
        self.path = path
        # Store everything in attributes...

    def deploy(self) -> Data:
        with open(path, 'r') as f:
            raw = f.read()
        stuff = json.loads(raw)
        data = Data(stuff, ...)
        return data

The instances of this class are used to store the initialization args
for Data, and on DataInfo instances are serialized/loaded.
Once the Data object is actually required (remember that
only very few of the instances are required at each moment), it is
constructed by calling deploy.

Maybe I’m misjudging this, but this pattern feels slightly awkward. Is this (roughly) the correct pattern for this situation? Does it have a name? Or are there more readable/less intrusive or well-known patterns that solve this problem (by “well-known” I mean something that for, for instance, be suggested in the official Qt documentation)?