Tekst źródłowy strony TI/Podstawy XML i jego parsowanie


<!--
* idea xml (język deklaratywny itp.)
* parsowanie xml za pomocą etree (lxml)
* idea pisania parsera (rekurencja i chodzenie po drzewach)
* co zrobić z plikami xml, które mają nazwę namespace'a w tagach
* DTD, XMLSchema - trzeba powiedzieć coś o walidacji dokumentów XML (ale nie za dużo bo to temat na osobny wykład).  -->
==XML==
Nazwa XML jest skrótem od {{ang|Extensible Markup Language}}, co w wolnym tłumaczeniu oznacza "rozszerzalny język znaczników". Sam XML jest uniwersalnym językiem przeznaczonym do reprezentowania różnych danych w strukturalizowany sposób.

{{solution|title=Język formalny|text= język złożony ze wszystkich słów (wyrażeń) uzyskiwanych za pomocą ściśle określonych reguł; definiowany zwykle przez gramatykę formalną (zgodnie ze składnią języka formalnego); podstawowe pojęcie lingwistyki matematycznej (za [http://encyklopedia.pwn.pl/haslo.php?id=3917941 Encyklopedią PWN]
).}}
XML nie jest językiem programowania i nie trzeba być programistą, by z niego korzystać. XML sprawia, że generowanie danych i ich odczyt są znacznie łatwiejsze, zapewniając strukturę łatwą do generacji i odczytu programowego. XML jest rozszerzalny i niezależny od platformy, i wykorzystuje Unicode do reprezentacji tekstu.

XML korzysta z tagów (słowa ujęte w '<' i '>') oraz atrybutów (w postaci nazwa="wartość"), bardzo podobnie do HTMLa. Jednakowoż HTML definiuje dokładne znaczenia każdego z tagów i jego atrybutów, jak również ich wygląd w przeglądarce, XML używa tagów tylko do rozgraniczenia pewnej części z całego dokumentu, a interpretację znaczenia pozostawia aplikacji odczytujacej te dane. I tak "&lt;p&gt;" w dokumencie XML-owym  nie oznacza początku paragrafu. W zależności od kontekstu, czy konstrukcji formatu danych taki tag może oznaczać dowolny parametr zaczynający się na "p" albo na inną literę alfabetu.

Pliki XML-owe tak samo jako HTML-owe są plikami tekstowymi. Dzięki temu można przeglądać dane bez potrzeby korzystania z dodatkowych aplikacji, a w ostateczności edytować je korzystając z edytora tekstu. Postać tekstowa umożliwia też łatwiejsze przeglądanie tekstu w celu usuwania błędów. 

W przeciwieństwie do HTML, reguły dotyczące plików XML są ścisłe i nie naruszalne. Źle napisany tag, zgubiony nawias czy atrybut nie ujęty w cudzysłów czyni plik XML bezużytecznym, podczas gdy w HTML taka praktyka jest dozwolona. Oficjalna specyfikacja języka XML zabrania aplikacjom domyślać się co ma znaczyć dany fragment uszkodzonego plik XML; jeśli w pliku jest błąd program powinien wstrzymać wykonywanie i zgłosić błąd.

Ze względu na postać tekstową danych i rozgraniczanie ich za pomocą tekstowych znaczników, pliki XML-owe są znacząco większe niż pliki biarne z takimi samymi danymi.

<blockquote>XML pozwala na zdefiniowanie nowego formatu poprzez łączenie lub korzystanie z innego. Ponieważ różne formaty są tworzone zupełnie niezalenie, mogą mieć tagi lub atrybuty o takiej samej nazwie, co powoduje dwuznaczność przy łączeniu takich dokumentów (np. w jednym "&lt;p&gt;" oznacza "paragraf", a w innym "pisarza"). W celu wyeliminowania takiej dwuznaczności w XML wprowadzona mechanizm przestrzeni nazw.(...)XML Schema został zaprojektowany, by odzwierciedlać to wsparcie dla modularności na poziomie definiowania struktury dokumentu XML, ułatwiając połaczeniu dwóch schematów w celu stworzenia trzeciego, który obejmuje strukturę połaczonych dokumentów.</blockquote>
([http://www.w3.org/XML/1999/XML-in-10-points.pl.html XML in 10 points], [http://www.w3.org/People/domain?domain=Communications W3C Communications Team] tłumaczenie Jacek Gleń)

=== Chwila refleksji ===

Zatrzymajmy się na chwilę, żeby się z oswoić z wyglądem pliku xml [http://escher.fuw.edu.pl/~mm/swps/swps_lb_1.xml prosciutkiego ] i [http://escher.fuw.edu.pl/~mm/swps/swps_lb_1.tag bardziej skomplikowanego]. Podziwiajmy przez chwilę drzewiastą strukturę tych plików, popatrzmy jakie są zasadnicze różnice między nimi.

==Parsery==

===lxml.etree===
Moduł lxml jest pythonową nakładką na na biblioteki [http://xmlsoft.org/ '''libxml2'''] i [http://xmlsoft.org/XSLT/ '''libxslt'''] napisane w języku <tt>C</tt>. Jest o tyle przyjemna, że łączy szybkość działania i kompletność z naturalnym dla nas interfejsem pythonowym i jest kompatybilna z [http://effbot.org/zone/element-index.htm '''ElementTree'''].

Poniższe przykłady są częściowo zaczerpnięte z [http://lxml.de/tutorial.html samouczka do '''lxml.etree'''] autorstwa '''Stefana Behnela'''.

====import====
Zazwyczaj piszemy:
<source lang="python">from lxml import etree</source>
W przypadku, gdy program nie będzie korzystał z funkcjonalności dostępnej wyłącznie w '''lxml.etree''' import można zrobić w następujący sposób:
<source lang="python">
try:
  from lxml import etree
  print "running with lxml.etree"
except ImportError:
  try:
    # Python 2.5
    import xml.etree.cElementTree as etree
    print "running with cElementTree on Python 2.5+"
  except ImportError:
    try:
      # Python 2.5
      import xml.etree.ElementTree as etree
      print "running with ElementTree on Python 2.5+"
    except ImportError:
      try:
        # normal cElementTree install
        import cElementTree as etree
        print "running with cElementTree"
      except ImportError:
        try:
          # normal ElementTree install
          import elementtree.ElementTree as etree
          print "running with ElementTree"
        except ImportError:
          print "failed to import ElementTree from any known place"
</source>
====Klasa <tt>Element</tt>====
<tt>Element</tt> jest podstawowym kontenerem w <tt>ElementTree</tt>. W większości wypadków do drzewa XML-owego dostajemy się przez tęże klasę. 

Tworzymy obiekt o nazwie <tt>root</tt> klasy <tt>Element</tt>:
<source lang="pycon">
>>> root = etree.Element("root")
</source>

Do XML-owej nazwy znacznika (taga) dostajemy się za pomocą pola <tt>tag</tt>:
<source lang="pycon">
>>> print root.tag
root
</source>

Obiekty klasy <tt>Element</tt> tworzą strukturę drzewa XML-owego. Żeby skontruować dzieci i dodać je do rodzica, można m.in. użyć metody <tt>append</tt>:
<source lang="pycon"> >>> root.append( etree.Element("child1") )</source>

Można też do tego użyć fabryki <tt>SubElement</tt>, która wymaga podania nazwy rodzica jako parametru oraz takich samych parametrów, jak fabryka <tt>Element</tt>.
<source lang="pycon">
>>> child2 = etree.SubElement(root, "child2")
>>> child3 = etree.SubElement(root, "child3")
</source>

Zobaczmy, jakie drzewo xml-owe stworzyliśmy:
<source lang="pycon">
>>> print(etree.tostring(root, pretty_print=True))
<root>
  <child1/>
  <child2/>
  <child3/>
</root>
</source>

====<tt>Element</tt>y są sekwencjami====
Żeby było jeszcze prościej, elementy zachowują się jak sekwencje:
<source lang="pycon">
>>> child = root[0]
>>> print child.tag
child1

>>> print len(root)
3

>>> root.index(root[1]) # tylko w lxml.etree!
1

>>> children = list(root)

>>> for child in root:
...     print child.tag
child1
child2
child3

>>> root.insert(0, etree.Element("child0"))
>>> start = root[:1]
>>> end   = root[-1:]

>>> print start[0].tag
child0
>>> print end[0].tag
child3

>>> root[0] = root[-1] # zmienia kolejność elementów w drzewie w lxml.etree
>>> for child in root:
...     print child.tag
child3
child1
child2
</source>
====<tt>Element</tt>y mają atrybuty====
W XML-u tagi mogą mieć atrybuty. Tagi z atrybutami, można tworzyć bezpośednio za pomocą klasy <tt>Element</tt>:
<source lang="pycon">
>>> root = etree.Element("przedmiot", interesujacy="strasznie")
>>> etree.tostring(root)
b'<przedmiot interesujacy="strasznie"/>'
</source>
Dostęp do atrybutów zapewniany jest przez metody <tt>set</tt> i <tt>get</tt>:
<source lang="pycon">
>>> print root.get("interesting")
None
>>> print root.get("interesujacy")
strasznie
>>> root.set("interesujacy","troszke")
>>> print root.get("interesujacy")
troszke
</source>
Za pomocą metody <tt>set</tt> można tez atrybuty dodawać:
<source lang="pycon">
>>> root.set("trudny","troszke")
>>> print root.get("interesujacy")
troszke
</source>
Atrybuty można też uzyskać za pomocą metody <tt>attrib</tt>:
<source lang="pycon">
>>> print root.attrib
{'interesujacy': 'troszke', 'trudny': 'troszke'}
</source>

=== Atrybuty są słownikami === 

Kontynuując poprzedni przykład, <tt>attrib</tt> zwraca nam słownik atrybutów danego taga:

<source lang="pycon">
>>> child = root[0]
>>> child.tag
'child1'
>>> child.set("atr", "1")
>>> print child
<Element child1 at 13943a0>
>>> child.attrib
{'atr': '1'}
>>> child.set("atr2", "2")
>>> child.attrib
{'atr2': '2', 'atr': '1'}
</source>

=== Pliki ===
Parsery xml jednak najczęściej służą do przetwarzania w jakiś sposób plików, a nie tylko tworzenia struktury xml'owej w pamięci, więc teraz przyjrzymy się prostym przykładom plików:
==== Odczyt ====
 <root>
 <child>One</child>
 <child>Two</child>
 </root>
Skopiujmy gdzieś ten kawałek, i zapiszmy pod nazwą example.xml.
<source lang="python">
>>> xml_file = "/sciezka/bezwzgledna/example.xml"
>>> tree = ET.parse(xml_file)
>>> element = tree.getroot()
>>> print element.tag
root
>>> for subelement in element:
	print subelement.text
	
One
Two
</source>

Żeby nie mieszało nam się, które słówka są kluczowe, a które możemy samodzielnie wymyślać, przepiszmy ten przykład na język polski:
 <korzen>
 <dziecko>Pierwsze</dziecko>
 <dziecko>Drugie</dziecko>
 </korzen>

<source lang="python">
>>> plik_xml = "/Users/magda/przyklad.xml"
>>> drzewko = ET.parse(plik_xml)
>>> el = drzewko.getroot()
>>> for podelement in el:
	print podelement.text
	
Pierwsze
Drugie
>>> print el.tag
korzen
</source>
Wzbogaćmy nasz przykładowy plik o atrybuty w tagach:
 <korzen>
 <dziecko atrybut="wartosc" atrybut2="wartosc2">Pierwsze</dziecko>
 <dziecko>Drugie</dziecko>
 </korzen>
<source lang="python">
from xml.etree import ElementTree as ET

plik_xml = "/Users/magda/przyklad.xml"
drzewko = ET.parse(plik_xml)
el = drzewko.getroot()
for podelement in el:
        print podelement.text
        print podelement.attrib

# Wynik wykonania:
>>>
Pierwsze
{'atrybut2': 'wartosc2', 'atrybut': 'wartosc'}
Drugie
{}
</source>
==== Zapis ====

=== Przydatne funkcje ===
API biblioteki lxml.etree oraz xml.etree są bardzo podobne. Na potrzeby naszych zajęć prawdopodobnie nawet nie zauważymy różnicy. Wygodna dokumentacja jest [http://docs.python.org/library/xml.etree.elementtree.html tu(xml.etree)] oraz [http://lxml.de/api/index.html tu (lxml)]
Poniżej kilka przykładów.
==== find / findall ==== 
pozwalające wybrać pierwszy/wszystkie tagi o zadanej nazwie:

 <korzen>
 <dziecko atrybut="wartosc" atrybut2="wartosc2">Pierwsze</dziecko>
 <dziecko>Drugie</dziecko>
 <atrapa>Atrapa</atrapa>
 <atrapa>Atrapa2</atrapa>
 <atrapa>Atrapa3</atrapa>
 </korzen>
 
<source lang="python">
from xml.etree import ElementTree as ET

plik_xml = "/Users/magda/przyklad.xml"
drzewko = ET.parse(plik_xml)
el = drzewko.getroot()
dzieci = el.findall("dziecko")
for d in dzieci:
        print d.text
atrapy = el.findall("atrapa")
for a in atrapy:
        print a.text

# Wynik wykonania:
>>>
Pierwsze
Drugie
Atrapa
Atrapa2
Atrapa3

</source>

A ile tagów o nazwie dziecko zostanie znalezione w tym przypadku?:

 <korzen>
 <dziecko atrybut="wartosc" atrybut2="wartosc2">Pierwsze</dziecko>
 <dziecko>Drugie</dziecko>
 <atrapa>Atrapa</atrapa>
 <atrapa>Atrapa2</atrapa>
 <atrapa>Atrapa3</atrapa>
 <dziecko>
         <dziecko>
                 <dziecko>
                 </dziecko>
         </dziecko>
 </dziecko>
 </korzen>

<source lang="python">
from xml.etree import ElementTree as ET

plik_xml = "/Users/magda/przyklad.xml"
drzewko = ET.parse(plik_xml)
el = drzewko.getroot()
dzieci = el.findall("dziecko")
print len(dzieci)

# Wynika wykonania:
>>>
3

</source>


=== Tworzenie własnego parsera ===

Do budowania drzewa, na którym potem wykonujemy wszystkie operacje, jest używany standardowy "parser". Ale czasem chcielibyśmy wykonać jakieś operacje już na etapie budowania drzewa. Mamy taką możliwość, możemy utworzyć własną klasę, której przedefiniujemy odpowiednie metody, i podać ją jako parametr odpowiednim funkcjom.
W szczególności w powyższych przykładach dotyczących plików mogliśmy funkcji parse jako drugi parametr podać nasz własny parser:

 xml.etree.ElementTree.parse(source, parser=None)
     Parses an XML section into an element tree. source is a filename or file object    containing XML data. parser is an optional parser instance. If not given, the standard XMLParser parser is used. Returns an ElementTree instance.

A oto przykład tworzenia własnego parsera, który przy okazji parsowania zlicza głębokość drzewka:

<source lang="pycon">
>>> from xml.etree.ElementTree import XMLParser
>>> class MaxDepth:                     # The target object of the parser
...     maxDepth = 0
...     depth = 0
...     def start(self, tag, attrib):   # Called for each opening tag.
...         self.depth += 1
...         if self.depth > self.maxDepth:
...             self.maxDepth = self.depth
...     def end(self, tag):             # Called for each closing tag.
...         self.depth -= 1
...     def data(self, data):
...         pass            # We do not need to do anything with data.
...     def close(self):    # Called when all data has been parsed.
...         return self.maxDepth
...
>>> target = MaxDepth()
>>> parser = XMLParser(target=target)
>>> exampleXml = """
... <a>
...   <b>
...   </b>
...   <b>
...     <c>
...       <d>
...       </d>
...     </c>
...   </b>
... </a>"""
>>> parser.feed(exampleXml)
>>> parser.close()
4

</source>

Pamiętaj, że gdy używamy argumentu target, XMLParser() nie zwraca automatycznie drzewa -- jesli chcemy, musimy sami je zbudować w naszej klasie, którą podajemy jako target.

==== Ćwiczenie ====
Napisz parser, który podczas budowania drzewa zlicza ilość elementów o nazwie child  Przetestuj jego działanie.

=== Zadania ===
:<b>Termin oddania projektów do 15-tego czerwca!</b>
:<b>Zmiany w terści zadań, wynikające z uwag studentów, akceptowane są do 1-go czerwca!</b>
==== Wstęp do projektu zaliczeniowego: Temat 1 &mdash; tworzenie klas na podstawie opisu w XML ====
=====Dynamiczna generacja klas=====
Python umożliwia dynamiczną generację klas.

Można to robić na dwa sposoby. W funkcji:
<source lang="python">
def klasa_p(p):
  class P(object):
     x = p
  return P
P_11 = klasa_p(11)
p_11 = P_11()
assert p_11.x == 11
</source>

Przy normalnej definicji klasy, wykonuje się sekwencja poleceń. Na końcu bloku <tt>class</tt> otrzymujemy pewien zestaw zmiennych w przestrzeni nazw (namespace), który jest słownikiem. Można też od razu stworzyć swój namespace, w tym ypadku pewien słownik i za pomocą funkcji <tt>type</tt> klasę o odpowieniej nazwie.
<source lang="Python">
B = type('B', (object,), dict(x=11))
assert B().x == 11
</source>
Argumentami funkcji type są &mdash; nazwa klasy, lista rodziców i treść klasy, czyli słownik. czyli de facto jej namespace.
Wiedząc, że w pythonie można dynamicznie tworzyć klasy tak jak w poniższym przykładzie:

I kolejne przykłady:
<ul><li><source lang="Python">
class C(object):
  def f(self, x): return x
  f = lambda x: None
assert C().f(33) == None
</source>
<li><source lang="python">
par = "self.y * self.y"
x = "y"
d={}
d[x] = 10
d["action"] = lambda self: eval(par)
Bar = type('Bar',(object,),d)
b = Bar()
print b.y
print b.action()
</source>
</ul>
=====Treść projektu=====
Napisz prosty program, który z zadanego opisu XML tworzy klasę. Opis XML może wyglądać np. tak:

 <class nazwa="Test">
 <attribute nazwa="y" wartosc="10">
 </attribute>
 <attribute nazwa="x" wartosc="5">
 </attribute>
 <method nazwa="action" tresc="self.y * self.y">
 </method>
 <method nazwa="metoda2" tresc="self.x * self.y">
 </method>
 </class>

W znaczniku class w atrybucie nazwa jest zapisana nazwa klasy. W znacznikach o nazwie "attribute" w atrybucie "nazwa" jest zapisana nazwa atrybutu klasy, w atrybucie "wartosc" -- jego wartosc.
W znacznikach "method" w atrybucie "nazwa" jest nazwa metody, a atrybucie "tresc" -- jej tresc. Dopuszczamy wyłącznie bardzo proste metody, bezparametrowe, operujące na atrybutach obiektu i wyłącznie zwracające wynik tych operacji.
Nieprecyzyjności w sformułowaniu należy zinterpretować na własną korzyść, tzn tak, jak nam ławiej zaimplementować rozwiązanie.

==== Projekt zaliczeniowy: Temat 1 -- tworzenie klas na podstawie opisu w XML ====

Rozwiń powyższe zadanie.
* Zaprojektuj sposób opisu klasy, uwzględniający możliwie dużo aspektów nie objętych obecną wersją, np.:
** metody z argumentami
** zmianę metody init
** metody, które coś wypisują
** oddzielnie metody klasowe od metod obiektu
** oddzielnie atrybuty klasowe od atrybutów obiektu
** dziedziczenie
...

Sposób opisu zaprojektowany przez Ciebie może być zupełnie inny niż zaproponowany we wstępie do zadania.
Napisz parser, który na podstawie opisu XML zgodnego z Twoimi "zasadami" zaimplementuje opisane klasy.


==== FAQ do Tematu 1 ====

==== Wstęp do projektu zaliczeniowego: Temat 2 ====


==== Projekt zaliczeniowy: Temat 2 -- Parsowanie pliku z metaopisem danych ====

Rozwiń swoją klasę do cięcia danych z pracowni o automatyczne wczytywanie wszystkich możliwych parametrów, typu częstość próbkowania, nazwy/ilość elektrod z zadanego pliku .xml
Format pliku .xml -- tak jak pliki .info z pracowni.
Przy ocenie zadania będzie brana pod uwagę dokładność implementacji: odporność na błędy, łapanie wyjątków, jakość dokumentacji, itd

==== FAQ do Tematu 2 ====

==Literatura==
Korzystałyśmy z:
# [http://www.w3.org/XML/1999/XML-in-10-points.pl.html XML in 10 points]
# [http://lxml.de/tutorial.html samouczek do lxml.etree]