RFC: Proposal: Deterministic Object Destruction
MRAB
python at mrabarnett.plus.com
Thu Mar 1 19:21:55 EST 2018
On 2018-03-01 23:38, ooomzay at gmail.com wrote:
> On Thursday, March 1, 2018 at 12:15:57 AM UTC, Paul Rubin wrote:
>> RAII is similar to Python's "with" statement. So it sounds like OP
>> wants to replace one "malignant carbuncle" with another one.
>
> I would like to understand why you think RAII is not substantially more
> pythonic than "With". Below I have sketched out a File-like resource
> management scenario using both PEP343 and RAII idioms for comparison.
>
> First lets look at the implementation of the competing resource management
> classes:-
>
>
> class PEP343FileAccess():
> '''
> A File Access-like resource with self-contained Context Manager for use
> with "with".
>
> This could be acheived with two separate classes but I don't think that
> adds anything except lines of code.
> '''
>
> # Structors
>
> def __init__(self, filename, mode):
> self.filename = filename
> self.mode = mode
> self.handle = None
> # dummy file content accessible only when handle is not None
> self.lines = ['one', 'two', 'three']
>
> # PEP343 Context Manager compliance
>
> def __enter__(self):
> self.handle = low_level_file_open(self.filename, self.mode) # fictitious
> return self
>
> def __exit__(self, extype, exvalue, extraceback):
> low_level_file_close(self.handle) # fictitious function
> self.handle = None
>
> # Example methods
>
> def __iter__(self):
> assert self.handle, "File has been closed"
> for line in self.lines:
> yield line
>
> def write(self, line):
> assert self.handle, "File has been closed"
> self.lines.append(line)
>
>
> class RAIIFileAccess():
> '''File Access-like Resource using RIAA idiom'''
>
> # Structors
>
> def __init__(self, filename, mode):
> self.handle = low_level_file_open(filename, mode) # fictitious
> # dummy content accessible as long as the object exists (invariant)
> self.lines = ['one', 'two', 'three']
>
> def __del__(self):
> low_level_file_close(self.handle) # fictitious function
>
> # Example methods
>
> def __iter__(self):
> for line in self.lines:
> yield line
>
> def write(self, line):
> self.lines.append(line)
>
>
> What I see is that PEP343 requires two new methods: __enter__ & __exit__.
> RIAA requires no new methods.
>
> RIAA resources are invariant: If you have a reference to it you can use it.
>
> PEP343 resources can not be invariant: To be robust the enter/exit state
> must be tracked and checked. (assert self.handle in the example)
>
> Now lets look at example resource usage:-
>
>
> def pep343_example():
>
> with PEP343FileAccess("src.txt", 'r') as src,
> PEP343FileAccess("dst.txt", 'w') as dst:
>
> for line in src:
> dst.write(line)
>
> def raii_example():
>
> src = RAIIFileAccess("src.txt", 'r')
> dst = RAIIFileAccess("dst.txt", 'w')
>
> for line in src:
> dst.write(line)
>
>
> PEP343 requires specialised "with" syntax, RIAA requires no new syntax.
>
> Furthermore, although src & dst objects are still accessible outside the
> PEP343 "with" block they are not in a usable state (not invariant).
>
> In the RIAA case the resources are guaranteed to be in a usable state as long
> as any reference exists (invariant). References can also be safely
> passed around.The resource will be freed/closed when the last man has finished
> with it, even in the face of exceptions.
>
What's the difference between 'RAIIFileAccess' and 'open'?
More information about the Python-list
mailing list