PySpark: make DataFrame no longer accessible

My goal is to write two functions capture and release which take a PySpark DataFrame as input and make it "inaccessible" to the user. The behavior I'm looking for is something like:

df = spark.read.csv("...") # or some other way or creating a DataFrame

df.show() # this should work

capture(df)

df.show() # this should no longer work, but return an exception, ideally one I control
df.count() # this should not work either

release(df)

df.count() # now this should work again

The method should ideally be independent of how the DataFrame was generated, e.g. approaches like "renaming the underlying file path" are not great (the program might also not have permissions to do so).

It would be even better to also prevent the DataFrame from being used indirectly, e.g.:

df = spark.read.csv("...") # or some other way or creating a DataFrame
df2 = df.withColumnRenamed("foo", "bar")

df2.show() # this should work

capture(df)

df2.show() # this should not work

release(df)

df2.show() # now this should work again

Is this possible? What's the cleanest way to get a behavior like this? I'm not looking for a solution that provides bulletproof security, just a way of warning the user if they're trying to do something that they likely didn't realize would cause issues.

More context on the question: we're building a library to make it easy to write and run differentially private pipelines on PySpark. For the privacy guarantees to hold, the private data must only be used once: as input to the differentially private program, and nowhere else. Using the private data in other places of the program (e.g. when defining hyperparameters) is a common class of pitfalls: users might do it because it's convenient, and fail to realize that this breaks the privacy guarantees. We're looking for ways of catching the most common examples of this pitfall, and making the private data inaccessible after initialization would be a useful mitigation.

For the first part, I can offer this piece of code :

class CustomDataframe:
    def __init__(self, dataframe):
        self._dataframe = dataframe
        self._locked = False

    def __getattr__(self, attr):
        """
        When we access an attribute or method we want to get the
        attribute/method of the dataframe object.

        Args:
            attr (str): Name of the attribute

        Returns:
            Attribute "attr" of the _dataframe object
        """
        if self._locked:
            raise Exception("custom exception")
        return getattr(self._dataframe, attr)

    def capture(self):
        self._locked = True

    def release(self):
        self._locked = False

Here, the release and capture are not functions but CustomDataframe's methods.

For the second use case, df2 doesn't have the information that it was df originally. So I do not really know how to do it ...