#-*- coding: utf-8 -*-
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 "" generuje akapit Kanta kgp.py template.xml czyta template.xml, aby określić, co ma generować
Ten program jest częścią książki "Zanurkuj w Pythonie", podręcznika o Pythonie dla doświadczonych programistów. Najnowszą wersję można znaleźć tu: http://pl.wikibooks.org/wiki/Zanurkuj_w_Pythonie.
Program ten został oparty na przykładach zawartych w książce "Dive Into Python", a dostępnej stąd: http://www.diveintopython.org. """
__author__ = "Mark Pilgrim ([email protected])" __version__ = "$Revision: 1.4 $" __date__ = "$Date: 2004/05/05 21:57:19 $" __copyright__ = "Copyright (c) 2001 Mark Pilgrim" __license__ = "Python"
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łow 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 -ó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 "", ponieważ 'section' jest jednym -em, który nie jest nigdzie -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 '' % 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 (przynajmnie dla nas), ale jego jedyne dziecko, node.documentElement jest: 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 ustawia flagę, aby pierwszą literę 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.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: , , 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 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
Znacznik jest odwołaniem do znacznika . Znacznik powoduje to, że zostaje wybrany w przypadkowy sposób potomek znacznika . """ id = node.attributes["id"].value self.parse(self.randomChildElement(self.refs[id]))
def do_p(self, node): u"""obsługuje znacznik
Znacznik jest jądrem gramatyki. Może zawierać niemal wszystko: tekst w dowolnej formie, znaczniki , znaczniki , a nawet inne znaczniki . 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
Znacznik zawiera jeden lub więcej znaczników . Jeden znacznik 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:])