Een blok met openen en opruimen verbinden

Sommige bewerkingen hebben een duidelijk begin en einde: je opent een lokale resource, gebruikt haar en sluit haar weer. Ook wanneer het gebruik mislukt, moet het afsluiten nog gebeuren. Een contextmanager verbindt die afspraken aan een with-blok.

Een eigen begin- en eindprotocol

Een contextmanager biedt __enter__ en __exit__ aan. De with-opdracht roept eerst __enter__ aan. De waarde die deze methode teruggeeft, komt bij de naam na as terecht.

Na het verlaten van het blok roept Python __exit__ aan, ook wanneer het blok met een return of een fout wordt verlaten. Dat geeft de contextmanager één duidelijke plaats voor opruiming. Het betekent niet dat iedere willekeurige fout vóór het binnengaan van het blok automatisch zo wordt afgehandeld.

class Session:
    def __init__(self, events):
        self.events = events
    def __enter__(self):
        self.events.append("open")
        return "lokaal"
    def __exit__(self, kind, error, traceback):
        self.events.append("dicht")
        return False

events = []
with Session(events) as name:
    print(name)
    events.append("werk")
print(events)

lokaal
['open', 'werk', 'dicht']

Het voorbeeld gebruikt een eenvoudig lokaal logboek, zonder bestanden of netwerk. Je ziet daarin eerst het openen, dan de handeling in het blok en ten slotte het sluiten. De concrete objecten maken de volgorde controleerbaar.

Het resultaat van enter gebruiken

__enter__ hoeft niet de contextmanager zelf terug te geven. Hij kan ook een ontvangen resource teruggeven waarmee het blok moet werken. De opdracht with_resource moet daarom de waarde na as doorgeven aan de ontvangen functie.

Een aanroep met de manager zelf zou bij sommige klassen toevallig werken maar bij andere het verkeerde object gebruiken. De controles onderscheiden die identiteiten bewust. Het resultaat van de handeling blijft daarnaast iets anders dan de waarde van __enter__.

Weten of het blok faalde

__exit__ ontvangt drie foutgegevens naast self: het fouttype, de foutinstantie en de traceback. Bij een normale afloop zijn die alle drie None. Bij een fout beschrijven ze de echte fout uit het blok.

RecordingScope bewaart ze straks als error_type, error en traceback. De constructor met de ontvangen resource en gebeurtenissenlijst is al gegeven.

Geef een onware waarde terug wanneer de fout gewoon moet doorlopen. Een ware retourwaarde onderdrukt die fout juist. Dat is een sterke gedragskeuze, geen onbelangrijke manier om de methode af te sluiten.

class IgnoreKey:
    def __init__(self, events):
        self.events = events
    def __enter__(self):
        self.events.append("start")
        return self
    def __exit__(self, kind, error, traceback):
        name = "geen" if kind is None else kind.__name__
        self.events.append("sluiten:" + name)
        return isinstance(error, KeyError)

for error in [KeyError("x"), ValueError("x")]:
    events = []
    try:
        with IgnoreKey(events):
            events.append("werk")
            raise error
    except ValueError:
        events.append("buiten:ValueError")
    print(events)

events = []
with IgnoreKey(events):
    events.append("werk")
print(events)

['start', 'werk', 'sluiten:KeyError']
['start', 'werk', 'sluiten:ValueError', 'buiten:ValueError']
['start', 'werk', 'sluiten:geen']

Het tweede voorbeeld onderdrukt alleen een afgesproken foutsoort. Een andere fout loopt door nadat de afsluitactie is uitgevoerd. Zo blijft zichtbaar dat opruimen en verbergen van een fout twee verschillende afspraken zijn.

Veelgemaakte fout: iedere fout ongemerkt inslikken

Een vaste return True in __exit__ laat ook onverwachte fouten verdwijnen. De aanroeper denkt dan misschien dat het blok normaal is voltooid. Gebruik die waarde alleen wanneer het concrete contract vraagt om de ontvangen fout af te handelen.

De opdracht RecordingScope onderdrukt geen fouten. Hij bewaart de ontvangen foutinformatie en registreert het afsluiten. Daardoor kan de aanroeper dezelfde oorspronkelijke exception blijven herkennen nadat het blok is verlaten.

Een with-blok werkelijk uitvoeren

Je kunt de juiste logteksten niet vervangen door alleen een lijst met vooraf bedachte resultaten. De functie with_resource moet het echte protocol van het ontvangen object gebruiken. Alleen dan bepaalt dat object welke resource wordt teruggegeven en hoe de afsluiting werkt.

Als __enter__ zelf faalt, is het blok nog niet binnengegaan en wordt __exit__ van die manager niet aangeroepen. Daarom kan de startactie zelf ook zorg nodig hebben wanneer zij gedeeltelijk iets opent. Deze les gebruikt kleine lokale fixtures om juist die protocolgrens zichtbaar te houden.

Een selectieve variant maken

Bij SuppressLookup vraagt de opdracht wel om een gerichte onderdrukking: alleen LookupError en subklassen daarvan worden als afgehandeld beschouwd. Een normale afloop blijft normaal en andere fouten lopen door. De gebruikte traceback en foutinstantie blijven de echte waarden die Python aanlevert.

Als __exit__ zelf een fout werpt, loopt die fout door, ook wanneer de handeling al een resultaat had. Was er al een bodyfout, dan blijft die via de exceptioncontext beschikbaar. Het tweede voorbeeld laat daarom ook de aparte normale afloop met drie None-gegevens zien.

Onthoud dit

• as ontvangt het resultaat van __enter__, niet automatisch de manager.
• __exit__ verbindt afsluiten aan normale afloop en fouten uit het blok.
• Een ware retourwaarde onderdrukt de ontvangen fout en vraagt een expliciete afspraak.

Hierna organiseer je zulke functies en klassen in modules en een eigen pakket.