Zanurkuj w Pythonie/Przetwarzanie XML-a

Z Wikibooks, biblioteki wolnych podręczników.
Skocz do: nawigacja, szukaj

Nurkujemy[edytuj]

Kolejne dwa rozdziały są na temat przetwarzania XML-a w Pythonie. Będzie to przydatne, jeśli już wiesz, jak wyglądają dokumenty XML, a które są wykonane ze strukturalnych znaczników określających hierarchię elementów itp. Jeśli nic z tego nie rozumiesz, możesz przeczytać coś na ten temat na Wikipedii.

Nawet jeśli nie interesuje Ciebie temat XML-a i tak dobrze by było przeczytać te rozdziały, ponieważ omawiają one wiele ważnych tematów jak pakiety, argumenty linii poleceń, a także jak wykorzystywać getattr jako pośrednik metod.

Bycie magistrem filozofii nie jest wymagane, chociaż jeśli kiedyś spotkaliśmy się z tekstami napisanymi przez Immanuel Kanta, lepiej zrozumiemy przykładowy program.

Mamy dwa sposoby pracy z XML-em. Jeden jest nazywany SAX (Simple API for XML), który działa w ten sposób, że czyta przez chwilę dokument XML i wywołuje dla każdego odnalezionego elementu odpowiednie metody. (Jeśli przeczytaliśmy rozdział 8, powinno to wyglądać znajomo, ponieważ w taki sposób pracuje moduł sgmllib.) Inny jest nazywany DOM (Document Object Model), a pracuje w ten sposób, że jednorazowo czyta cały dokument XML i tworzy wewnętrzną reprezentację, wykorzystując klasy Pythona powiązane w strukturę drzewa. Python posiada standardowe moduły do obydwu sposobów parsowania, ale rozdział ten opisze tylko, jak wykorzystywać DOM.

Poniżej znajduje się kompletny program Pythona, który generuje pseudolosowe wyjście oparte na gramatyce bezkontekstowej zdefiniowanej w formacie XML. Nie przejmujmy się, jeśli nie zrozumieliśmy, co to znaczy. Będziemy głębiej badać zarówno wejście programu, jak i jego wyjście w tym i następnym rozdziale.

Przykład. kgp.py
u"""Generator Kanta dla Pythona

Generuje pseudofilozofię opartą na gramatyce bezkontekstowej

Użycie: python kgp.py [options] [source]

Opcje:
  -g ..., --grammar=...   używa określonego pliku gramatyki lub adres URL
  -h, --help              wyświetla ten komunikat pomocy
  -d                      wyświetla informacje debugowania podczas parsowania

Przykłady:
  kgp.py                  generuje kilka akapitów z filozofią Kanta
  kgp.py -g husserl.xml   generuje kilka akapitów z filozofią Husserla
  kpg.py "<xref id='paragraph'/>"  generuje akapit Kanta
  kgp.py template.xml     czyta template.xml, aby określić, co ma generować
 """

from xml.dom import minidom
import random
import toolbox
import sys
import getopt

_debug = 0

class NoSourceError(Exception): pass

class KantGenerator(object):
    u"""generuje pseudofilozofię opartą na gramatyce bezkontekstowej"""
    
    def __init__(self, grammar, source=None):
        self.loadGrammar(grammar)
        self.loadSource(source and source or self.getDefaultSource())
        self.refresh()

    def _load(self, source):
        u"""wczytuje XML-owe źródło wejścia, zwraca sparsowany dokument XML

        - adres URL z plikiem XML ("http://diveintopython.org/kant.xml")
        - nazwę lokalnego pliku XML ("~/diveintopython/common/py/kant.xml")
        - standardowe wejście ("-")
        - bieżący dokument XML w postaci łańcucha znaków
        """
        sock = toolbox.openAnything(source)
        xmldoc = minidom.parse(sock).documentElement
        sock.close()
        return xmldoc

    def loadGrammar(self, grammar):
        u"""wczytuje gramatykę bezkontekstową"""
        self.grammar = self._load(grammar)
        self.refs = {}
        for ref in self.grammar.getElementsByTagName("ref"):
            self.refs[ref.attributes["id"].value] = ref
        
    def loadSource(self, source):
        u"""wczytuje źródło source"""
        self.source = self._load(source)

    def getDefaultSource(self):
        u"""zgaduje domyślne źródło bieżącej gramatyki
        
        Domyślnym źródłem będzie jeden z <ref>-ów, do którego nic się
        nie odwołuje. Może brzmi to skomplikowanie, ale tak naprawdę nie jest.
        Przykład: Domyślnym źródłem dla kant.xml jest
        "<ref id='section'/>", ponieważ 'section' jest jednym <ref>-em, który
        nie jest nigdzie <xref>-em w gramatyce.
        W wielu gramatykach, domyślne źródło będzie tworzyło
        najdłuższe (i najbardziej interesujące) wyjście.
        """
        xrefs = {}
        for xref in self.grammar.getElementsByTagName("xref"):
            xrefs[xref.attributes["id"].value] = 1
        xrefs = xrefs.keys()
        standaloneXrefs = [e for e in self.refs.keys() if e not in xrefs]
        if not standaloneXrefs:
            raise NoSourceError, "can't guess source, and no source specified"
        return '<xref id="%s"/>' % random.choice(standaloneXrefs)
        
    def reset(self):
        u"""resetuje parser"""
        self.pieces = []
        self.capitalizeNextWord = 0

    def refresh(self):
        u"""resetuje bufor wyjściowy, ponownie parsuje cały plik źródłowy i zwraca wyjście
        
        Ponieważ parsowanie dosyć dużo korzysta z przypadkowości, jest to
        łatwy sposób, aby otrzymać nowe wyjście bez potrzeby ponownego wczytywania
        pliku gramatyki.
        """
        self.reset()
        self.parse(self.source)
        return self.output()

    def output(self):
        u"""wyjściowy, wygenerowany tekst"""
        return "".join(self.pieces)

    def randomChildElement(self, node):
        u"""wybiera przypadkowy potomek węzła
        
        Jest to użyteczna funkcja wykorzystywana w do_xref i do_choice.
        """
        choices = [e for e in node.childNodes
                   if e.nodeType == e.ELEMENT_NODE]
        chosen = random.choice(choices)
        if _debug:
            sys.stderr.write('%s available choices: %s\n' % \
                (len(choices), [e.toxml() for e in choices]))
            sys.stderr.write('Chosen: %s\n' % chosen.toxml())
        return chosen

    def parse(self, node):
        u"""parsuje pojedynczy węzeł XML
        
        Parsowany dokument XML (from minidom.parse) jest drzewem węzłów
        złożonym z różnych typów.  Każdy węzeł reprezentuje instancję
        odpowiadającej jej klasy Pythona (Element dla znacznika, Text 
        dla danych tekstowych, Document dla dokumentu).  Poniższe wyrażenie
        konstruuje nazwę klasy opartej na typie węzła, który parsujemy
        ("parse_Element" dla węzła o typie Element,
        "parse_Text" dla węzła o typie Text itp.), a następnie wywołuje te metody.
        """
        parseMethod = getattr(self, "parse_%s" % node.__class__.__name__)
        parseMethod(node)

    def parse_Document(self, node):
        u"""parsuje węzeł dokumentu
        
        Węzeł dokument sam w sobie nie jest interesujący (przynajmniej dla nas), ale
        jego jedyne dziecko, node.documentElement jest głównym węzłem gramatyki.
        """
        self.parse(node.documentElement)

    def parse_Text(self, node):
        u"""parsuje węzeł tekstowy
        
        Tekst węzła tekstowego jest zazwyczaj dodawany bez zmiany do wyjściowego bufora. 
        Jedynym wyjątkiem jest to, że <p class='sentence'> ustawia flagę, aby
        pierwsza litera następnego słowa była wielka. Jeśli ta flaga jest ustawiona,
        pierwszą literę tekstu robimy wielką i resetujemy tę flagę.
        """
        text = node.data
        if self.capitalizeNextWord:
            self.pieces.append(text[0].upper())
            self.pieces.append(text[1:])
            self.capitalizeNextWord = 0
        else:
            self.pieces.append(text)

    def parse_Element(self, node):
        u"""parsuje element
        
        XML-owy element odpowiada bieżącemu znacznikowi źródła:
        <xref id='...'>, <p chance='...'>, <choice> itp.
        Każdy typ elementu jest obsługiwany za pomocą odpowiedniej, własnej metody. 
        Podobnie jak to robiliśmy w parse(), konstruujemy nazwę metody
        opartej na nazwie elementu ("do_xref" dla znacznika <xref> itp.), a potem
        wywołujemy tę metodę.
        """
        handlerMethod = getattr(self, "do_%s" % node.tagName)
        handlerMethod(node)

    def parse_Comment(self, node):
        u"""parsuje komentarz
        
        Gramatyka może zawierać komentarze XML, ale my je pominiemy
        """
        pass
    
    def do_xref(self, node):
        u"""obsługuje znacznik <xref id='...'>
        
        Znacznik <xref id='...'> jest odwołaniem do znacznika <ref id='...'>.
        Znacznik <xref id='sentence'/> powoduje to, że zostaje wybrany w przypadkowy sposób
        potomek znacznika <ref id='sentence'>.
        """
        id = node.attributes["id"].value
        self.parse(self.randomChildElement(self.refs[id]))

    def do_p(self, node):
        u"""obsługuje znacznik <p>
        
        Znacznik <p> jest jądrem gramatyki. Może zawierać niemal
        wszystko: tekst w dowolnej formie, znaczniki <choice>, znaczniki <xref>, a nawet
        inne znaczniki <p>. Jeśli atrybut "class='sentence'" zostanie znaleziony, flaga
        zostaje ustawiona i następne słowo będzie zapisane dużą literą.  Jeśli zostanie
        znaleziony atrybut "chance='X'", to mamy X% szansy, że znacznik zostanie wykorzystany
        (i mamy (100-X)% szansy, że zostanie całkowicie pominięty)
        """
        keys = node.attributes.keys()
        if "class" in keys:
            if node.attributes["class"].value == "sentence":
                self.capitalizeNextWord = 1
        if "chance" in keys:
            chance = int(node.attributes["chance"].value)
            doit = (chance > random.randrange(100))
        else:
            doit = 1
        if doit:
            for child in node.childNodes: self.parse(child)

    def do_choice(self, node):
        u"""obsługuje znacznik <choice>
        
        Znacznik <choice> zawiera jeden lub więcej znaczników <p>. Jeden znacznik <p>
        zostaje wybrany przypadkowo i jest następnie wykorzystywany do generowania
        tekstu wyjściowego.
        """
        self.parse(self.randomChildElement(node))

def usage():
    print __doc__

def main(argv):
    grammar = "kant.xml"
    try:
        opts, args = getopt.getopt(argv, "hg:d", ["help", "grammar="])
    except getopt.GetoptError:
        usage()
        sys.exit(2)
    for opt, arg in opts:
        if opt in ("-h", "--help"):
            usage()
            sys.exit()
        elif opt == '-d':
            global _debug
            _debug = 1
        elif opt in ("-g", "--grammar"):
            grammar = arg
    
    source = "".join(args)
    k = KantGenerator(grammar, source)
    print k.output()

if __name__ == "__main__":
    main(sys.argv[1:])
Przykład. toolbox.py
u"""Różnorodne użyteczne funkcje"""

def openAnything(source):
    u"""URI, nazwa pliku lub łańcuch znaków --> strumień

    Funkcja ta pozwala zdefiniować parser, który przyjmuje dowolne źródło wejścia
    (URL, ścieżkę do lokalnego pliku lub znajdującego się gdzieś w sieci, 
    czy też bieżące dane w postaci łańcucha znaków)
    i traktuje je w odpowiedni sposób. Zwracany obiekt będzie zawierał
    wszystkie podstawowe metody odczytu (read, readline, readlines).
    Kiedy już obiekt nie będzie potrzebny, należy go 
    zamknąć za pomocą metody .close().
    
    Przykłady:
    >>> from xml.dom import minidom
    >>> sock = openAnything("http://localhost/kant.xml")
    >>> doc = minidom.parse(sock)
    >>> sock.close()
    >>> sock = openAnything("c:\\inetpub\\wwwroot\\kant.xml")
    >>> doc = minidom.parse(sock)
    >>> sock.close()
    >>> sock = openAnything("<ref id='conjunction'><text>and</text><text>or</text></ref>")
    >>> doc = minidom.parse(sock)
    >>> sock.close()
    """

    if hasattr(source, "read"):
        return source
    
    if source == "-":
        import sys
        return sys.stdin

    # próbuje otworzyć za pomocą modułu urllib (gdy source jest plikiem dostępnym z http,
    # ftp lub URL-a)
    import urllib
    try:
        return urllib.urlopen(source)
    except (IOError, OSError):
        pass
    
    # próbuje otworzyć za pomocą wbudowanej funkcji open (jeśli source jest ścieżką
    # do lokalnego pliku)
    try:
        return open(source)
    except (IOError, OSError):
        pass
    
    # traktuje source jako łańcuch znaków
    import StringIO
    return StringIO.StringIO(str(source))

Uruchom sam program kgp.py, który będzie parsował domyślną, opartą na XML gramatykę w kant.xml, a następnie wypisze kilka filozoficznych akapitów w stylu Immanuela Kanta.

Przykład. Przykładowe wyjście kgp.py
[you@localhost kgp]$ python kgp.py
    As is shown in the writings of Hume, our a priori concepts, in
reference to ends, abstract from all content of knowledge; in the study
of space, the discipline of human reason, in accordance with the
principles of philosophy, is the clue to the discovery of the
Transcendental Deduction.  The transcendental aesthetic, in all
theoretical sciences, occupies part of the sphere of human reason
concerning the existence of our ideas in general; still, the
never-ending regress in the series of empirical conditions constitutes
the whole content for the transcendental unity of apperception.  What
we have alone been able to show is that, even as this relates to the
architectonic of human reason, the Ideal may not contradict itself, but
it is still possible that it may be in contradictions with the
employment of the pure employment of our hypothetical judgements, but
natural causes (and I assert that this is the case) prove the validity
of the discipline of pure reason.  As we have already seen, time (and
it is obvious that this is true) proves the validity of time, and the
architectonic of human reason, in the full sense of these terms,
abstracts from all content of knowledge.  I assert, in the case of the
discipline of practical reason, that the Antinomies are just as
necessary as natural causes, since knowledge of the phenomena is a
posteriori.
    The discipline of human reason, as I have elsewhere shown, is by
its very nature contradictory, but our ideas exclude the possibility of
the Antinomies.  We can deduce that, on the contrary, the pure
employment of philosophy, on the contrary, is by its very nature
contradictory, but our sense perceptions are a representation of, in
the case of space, metaphysics.  The thing in itself is a
representation of philosophy.  Applied logic is the clue to the
discovery of natural causes.  However, what we have alone been able to
show is that our ideas, in other words, should only be used as a canon
for the Ideal, because of our necessary ignorance of the conditions.

[...ciach...]

Jest to oczywiście kompletny bełkot. No dobra, nie całkowity bełkot. Jest składniowo i gramatycznie poprawny (chociaż bardzo wielomówny). Niektóre fragmenty mogą być rzeczywiście prawdą (lub przy najmniej z niektórymi Kant by się zgodził), a niektóre są ewidentnie nieprawdziwe, a wiele fragmentów jest po prostu niespójnych. Lecz wszystko jest w stylu Immanuela Kanta.

Interesującą rzeczą w tym programie jest to, że nie ma tu nic, co określa Kanta. Cała zawartość poprzedniego przykładu pochodzi z pliku gramatyki, kant.xml. Jeśli każemy programowi wykorzystać inny plik gramatyki (który możemy określić z linii poleceń), wyjście będzie kompletnie różne.

Przykład. Proste wyjście kgp.py
[you@localhost kgp]$ python kgp.py -g binary.xml
00101001
[you@localhost kgp]$ python kgp.py -g binary.xml
10110100