20.4    Das Paket importlib 

Das Paket importlib der Standardbibliothek implementiert das Importverhalten, das der import-Anweisung zugrunde liegt. Es gibt drei grundlegende Einsatzzwecke für dieses Paket:

• Es enthält die Funktion import_module, über die sich ein Modul bzw. ein Paket importieren lässt, ohne die import-Anweisung zu verwenden. Das ist zum Beispiel interessant, wenn der Name des einzubindenden Moduls als String vorliegt.
• Es definiert sogenannte Importer. Über diese Importer ist es möglich, in den Importvorgang einzugreifen und damit das Standardverhalten der import-Anweisung zu modifizieren.
• Die Implementierung des Importvorgangs ist damit in der Sprache Python selbst geschrieben. Das bedeutet insbesondere, dass alternative Python-Interpreter keine eigene Implementierung mitbringen müssen, sondern ebenfalls auf importlib zurückgreifen können.

 

20.4.1    Einbinden von Modulen und Paketen 

Das Paket importlib definiert die Funktion import_module, mit deren Hilfe sich ein Modul einbinden lässt, ohne die import-Anweisung zu verwenden. Die Funktion import_module bekommt den Namen des einzubindenden Moduls bzw. Pakets als String übergeben:

>>> import importlib
>>> math = importlib.import_module("math")
>>> math.cos(0)
1.0

Das eingebundene Modul wird von import_module zurückgegeben.

Wenn ein relativer Import durchgeführt werden soll, muss für den optionalen zweiten Parameter ein String übergeben werden, der den Pfad zum Basispaket enthält, auf den sich der relative Import bezieht.

Bezug nehmend auf die Paketstruktur aus Abbildung 20.1 ist die relative import-Anweisung

from ..bmp import read

aus den vorangegangenen Beispielen etwa äquivalent zu den folgenden Aufrufen von import_module:

read = importlib.import_module("..bmp.read", __package__)
read = importlib.import_module("..bmp.read", "formats.png")
read = importlib.import_module(".bmp.read", "formats")

 

20.4.2    Verändern des Import-Verhaltens 

Aus Anwendersicht ist der wesentliche Aspekt des Pakets importlib sicherlich die Definition der Funktion import_module; das Paket bietet darüber hinaus aber interessante Möglichkeiten, in den Importprozess des Interpreters einzugreifen. Es ist mit diesen Methoden zum Beispiel möglich, Module aus komprimierten Archiven oder aus dem Internet zu laden. Man könnte sich auch vorstellen, Module beim Einbinden dynamisch zu erzeugen. Deshalb geben wir Ihnen an dieser Stelle eine kurze Übersicht darüber, wie das Einbinden von Modulen und Paketen intern funktioniert und wie Sie ein selbst definiertes Verhalten implementieren können.

Das Importverhalten wird festgelegt durch eine Kombination sogenannter Finder und Loader. Ein Finder lokalisiert das einzubindende Modul anhand seines Namens und instanziiert einen passenden Loader, der es einbindet. In der Liste sys.path_hooks sind die systemweit registrierten Finder eingetragen. Da es verschiedene Arten von Orten gibt, an denen Finder nach Modulen suchen können, werden für jeden Eintrag in sys.path die registrierten Finder der Reihe nach gefragt, ob sie für diesen Pfad geeignet sind. Der erste Finder in sys.path_hooks, der sich für einen der Pfade für geeignet erklärt, ist dafür zuständig, Module in diesem Pfad zu finden.

Bei der Abarbeitung einer import-Anweisung werden die in sys.path eingetragenen Pfade der Reihe nach durchgegangen, und der assoziierte Finder wird beauftragt, das einzubindende Modul zu finden. Findet einer der Finder das Modul, muss der von ihm instanziierte Loader das Modul einbinden. Auch hier gilt: Nachdem der erste Finder das Modul gefunden hat, wird die Suche abgebrochen.

Der Finder

Ein Finder ist eine Klasse, die neben ihrem Konstruktor eine Methode find_module enthält. Diese Methode wird gerufen, wenn ein Modul in einem dem Finder zugeordneten Pfad gesucht wird. Über den Konstruktor teilt der Finder mit, für welche Pfade er geeignet ist. Im Folgenden entwickeln wir einen beispielhaften Finder, der Textdateien als Module identifiziert:

class TextFinder:
    def __init__(self, path):
        if path != "#":
            raise ImportError
    def find_module(self, fullname, path=None):
        try:
            open(fullname + ".txt").close()
            return TextLoader(path)
        except FileNotFoundError:
            return None

Für jeden Eintrag in sys.path, der noch keinen assoziierten Finder hat, werden die registrierten Finder der Reihe nach instanziiert. Bei der Instanziierung wird der jeweilige Pfad an den Konstruktor übergeben. Wenn ein Finder für den angegebenen Pfad nicht zuständig sein möchte, muss er eine ImportError-Exception werfen. Im Beispiel schreiben wir einen Finder, der nur für den Pfad "#" zuständig ist. Das ist ein künstlicher Eintrag, den wir später in sys.path hinzufügen, um das restliche Importverhalten nicht zu beeinträchtigen.

Die Methode find_module wird gerufen, wenn der Finder beauftragt wird, ein Modul mit dem Namen fullname zu finden. Dazu prüft er, ob die Datei fullname.txt existiert, und instanziiert gegebenenfalls einen dazu passenden Loader, in diesem Fall einen TextLoader zum Einbinden einer Textdatei.

Der Loader

Ein Loader implementiert im Wesentlichen die Methode load_module, die den Modulnamen übergeben bekommt. Sie ist dafür zuständig, das Modul einzubinden und die entstandene Modulinstanz zurückzugeben. Außerdem muss das Modul im Modulindex sys.modules eingetragen werden, und es müssen verschiedene Attribute des Moduls initialisiert werden.

Wenn das Modul bereits in sys.modules vorhanden ist, es also ein zweites Mal eingebunden wird, sollte ein Loader die in sys.modules enthaltene Instanz zurückgeben. Wenn das Laden eines Moduls scheitert, wirft load_module eine ImportError-Exception.

Zum Erzeugen einer neuen Modulinstanz kann die Funktion new_module des Moduls imp aus der Standardbibliothek verwendet werden.

import imp
class TextLoader:
    def __init__(self, path):
        pass
    def load_module(self, fullname):
        if fullname in sys.modules:
            return sys.modules[fullname]
        else:
            module = imp.new_module(fullname)
            sys.modules[fullname] = module
        module.__file__ = fullname + ".txt"
        module.__name__ = fullname
        module.__package__ = ""
        module.__loader__ = self
        try:
            with open(fullname + ".txt") as f:
                module.text = f.read()
            return module
        except FileNotFoundError:
            del sys.modules[fullname]
            raise ImportError

In der Beispielimplementierung versuchen wir, die zum Modulnamen passende Textdatei zu lesen, und fügen im Erfolgsfall den enthaltenen Text als Attribut text in das Modul ein.

Um das Importieren von Textdateien zu testen, muss der TextFinder als Finder registriert und außerdem der virtuelle Pfad "#" in sys.path eingetragen werden:

import sys
sys.path_hooks.append(TextFinder)
sys.path.append("#")

Sowohl die Finder-Klasse als auch der virtuelle Pfad können weiter vorne in den jeweiligen Listen eingefügt werden, um ihnen eine höhere Priorität zu geben.

Wenn jetzt ein Modul eingebunden wird, werden wie gewohnt die in sys.path enthaltenen Pfade abgearbeitet. Da der virtuelle Pfad "#" ans Ende der Liste angefügt wurde, werden zunächst die Standard-Finder mit den Standardpfaden überprüft. Sollte keiner der Standard-Finder das Modul finden können, versucht der TextFinder, das Modul als Textdatei zu laden:

>>> import testdatei
>>> print(testdatei.text)
Dies ist der Inhalt der Testdatei

Finder und Loader können, wie im Beispiel gezeigt, voneinander getrennte Klassen sein, sie können aber auch ein und dieselbe Klasse sein. In diesem Fall darf die Methode find_module die eigene Instanz – self – zurückgeben.