Tekst źródłowy strony /Cw7

= [[TI:WTBD]]/Ćwiczenia 7 =

== Rozbiór archiwum poczty (listy dyskusyjnej) ==
zapisanego w postaci pojedynczego pliku (typu [http://en.wikipedia.org/wiki/Mbox ''mbox'']) na poszczególne maile, a następnie -- każdego maila, na nagłówki i treść, za pomocą wyrażeń regularnych.
:Przykładowe dane można znaleźć np. w [http://mail.python.org/pipermail/python-list/ archiwum listy dyskusyjnej o Pythonie] -- pod ,,Downloadable version".
<source lang="python">
#! /usr/bin/python
# coding: utf-8
# mailparse.py

import re
mailsrx = re.compile(r'^From \S+ at .*\n$')
mbodyrx = re.compile(r'\n\n')
headsrx = re.compile(r'^([-\w]+): +((?:.|\n +)*)$', re.MULTILINE)

def lines2mails(lines):
    '''wyciągamy linijka po linijce dopóki nie zbierze się z nich pełny mail,
    co poznamy gdy napotkamy linijkę separującą. Wtedy łączymy linijki 
    w jeden string, i "ustępujemy" (yield).
        lines: iterator podający kolejne linijki
        wynikiem jest generator kolejnych maili'''

    l_out = list()
    for line in lines:
        if not mailsrx.match(line):
            l_out.append(line)
        elif l_out:
            yield ''.join(l_out)
            l_out = list()
    yield ''.join(l_out)

def mailsplit(rawmail):
    '''rozdzielamy "surowy" mail na blok nagłówków i resztę.
    '''
    return tuple(mbodyrx.split(rawmail, maxsplit=1))

def parsehead(head):
    '''analizujemy blok nagłówków na poszczególne nagłówki, tzn. dwójki 
    (klucz, wartość).
    '''
    headers = headsrx.findall(head)
    return headers

def main():
    '''żeby to wszystko przetestować analizujemy plik(i) wejściow(y|e)
    i wypisujemy dane z nagłówków 'From', 'Date' i 'Subject'.'''

    from fileinput import input

    rawmails = lines2mails(input())
    splitmails = (mailsplit(item) for item in rawmails)
    parsedmails = ((parsehead(head), body) for (head, body) in splitmails)
    for pm in parsedmails:
        headers, body = pm
        headers = dict(headers)
        print '{From}\t{Date}\t{Subject}'.format(**headers)
        
if __name__ == '__main__':
    main()
</source>

== Wykrywanie w plikach z kodem źródłowym w Pythonie instrukcji powodujących import modułów, ==
i sporządzenie na tej podstawie listy modułów, od których zależy dany kod.
:Może to być zaskakujące, ale zadania takiego nie da się zrealizować w 100 procentach. Weźmy pod uwagę np.

<source lang="python">
'''
import re
'''
</source>

za pomocą ''jedynie'' technik opartych na wyrażeniach regularnych nie da się w pełni skutecznie rozpoznać, że ta instrukcja ''import'' jest częścią ''stałej napisowej'', a nie prawdziwą instrukcją. Mniejsza zresztą o teoretyczną niemożliwość, na pewno w praktyce jest to zbyt trudne -- trzeba wziąć pod uwagę, że w programie może występować wiele stałych napisowych, a więc trzeba liczyć otwarcia/zamknięcia cudzysłowów, w dodatku cudzysłowy różnych rodzajów wolno zagnieżdżać... Widać, że rozbiór składniowy (parsowanie) języków programowania (jak Python) nie może się opierać na technice wyrażeń regularnych. Na szczęście, interesują nas głównie pliki danych, których składnia ma większe szanse być (przynajmniej w przybliżeniu) ''regularna'', czyli możliwa do opanowania wyrażeniami regularnymi.
Inne przypadki sprawiające problemy to np.:
<source lang="python">
if warunek: import re

try: import foobar
except: pass
</source>
Zwłaszcza ten pierwszy jest nie do opanowania: ''warunek'' może być bardzo złożonym wyrażeniem, z wielokrotnie zagnieżdżonymi nawiasami i cudzysłowami (stałe napisowe)! 
Te ,,wyjątkowe" przypadki mają tyle ze sobą wspólnego, że są w praktyce ''rzadkie''. To znaczy, że mało kto w rzeczywistości tak pisze kod, a nikt tak pisać ''nie musi''. Możemy więc założyć, że analizujemy kod nie tylko poprawny składniowo (chyba jest już jasne, że poprawności składniowej kodu w Pythonie z zasadniczych powodów ''nie da się'' zweryfikować ''tylko'' za pomocą wyrażeń regularnych); ale w dodatku przestrzegający pewnych zasad ,,dobrego stylu": np., że ''import'' wewnątrz instrukcji warunkowej zaczyna się od nowej linii; albo, że w stałej znakowej, linia zaczynająca się od słowa ''import'' powinna być ujęta w oddzielny cudzysłów. 
Z tymi zastrzeżeniami, spróbujmy znaleźć rozwiązanie, które skutkuje jeśli za przykład testowy potraktować coś takiego jak poniżej:
<source lang="python">
from os import *
import sys
import string , re
import\
csv
#import lineinput # do not import
from os.path\
    import isfile, isdir

def funkcja():
    import numpy as np
    pass

import numpy.random as rand, pylab

# wynik powinien być: csv numpy numpy.random os os.path pylab re string sys
</source>
W szczególności należy wziąć pod uwagę, że pomiędzy jednostkami leksykalnymi (słowami) tworzącymi polecenie, wszędzie tam, gdzie wymagany jest odstęp (ciąg co najmniej 1 spacji/tabulacji), może on mieć również postać '\' plus bezpośrednio po ukośniku przejście do nowej linii.
Specyfikacja ogólnej postaci odstępu pomiędzy słowami może więc wyglądać tak: <code>(?:[ \t]|\\\n)+</code> gdzie do grupowania wyrażeń użyłem <code>(?: ... )</code> tworzącego grupę nieprzechwytującą (nie interesuje mnie, jakiej dokładnie postaci odstępu rozdzielającego użyto..). Ukośnik '\' musi być potrojony, by został potraktowany raz dosłownie, a drugi raz -- jako tworzący wraz z literą 'n' sekwencję reprezentującą kod nowej linii.

<source lang="python">
#! /usr/bin/python
# coding: utf-8
# findimports.py

import re

fromimportrx = re.compile(
                        r'^[ \t]*from'     # ewentualne wcięcie
                        r'(?:[ \t]|\\\n)+' # odstępy lub nowa linia z backslashem
                        r'(\w+(?:\.\w+)*)' # nazwa modułu
                        r'(?:[ \t]|\\\n)+' # znów odstępy itd.
                        r'import'          # dalej już nieważne co
                        , re.MULTILINE)
importrx = re.compile(
                    r'^[ \t]*import'
                    r'(?:[ \t]|\\\n)+'
                    r'((?:'
                    r'(?:\w+(?:\.\w+)*)' # nazwa modułu, ewent. słowo `as'
                    r'|(?:[ \t]|\\\n)'   # odstępy itd.
                    r'|,)+)' # ,p1.mod1 as alias1, mod2, p3 ...
                    , re.MULTILINE)

importas = re.compile(
                    r'^(\w+(?:\.\w+)*)'  # nazwa
                    r'(?:'
                    r'(?:[ \t]|\\\n)+'
                    r'as'
                    r'(?:[ \t]|\\\n)+'
                    r'\w+'               # alias, nieważne jaki
                    r')?'
                    r'$')

def find_imports(source):
    imports = set()
    found = importrx.findall(source)
    for s in found:
        imports |= set(importas.search(sss).group(1)
                        for sss in (
                            ss.strip() for ss in s.split(',')
                            )
                    )
    found = fromimportrx.findall(source)
    imports |= set(found)
    return imports

def test():
    imports = find_imports(test_string)
    for item in sorted(imports):
        print item,
    print

test_string = '''
from os import *
import sys
import string , re
import\
csv
#import lineinput # do not import
from os.path\
    import isfile, isdir

def funkcja():
    import numpy as np
    pass

import numpy.random as rand, pylab

# wynik powinien być: csv numpy numpy.random os os.path pylab re string sys
'''

def main():
    from optparse import OptionParser
    parser = OptionParser()
    parser.add_option('-t', '--test', action='store_true', dest='test', default=False)
    parser.add_option('-v', '--verbose', action='store_true', dest='verbose', default=False)
    opts, args = parser.parse_args()
    if opts.test:
        test()
        return
    imports = dict()
    for fname in args:
        imports[fname] = find_imports(open(fname).read())
    all_imports = set().union(*imports.values())
    if opts.verbose:
        print 'All imports:',
    for item in sorted(all_imports):
        print item,
    print
    if opts.verbose:
        for fname in args:
            print fname + ':',
            for item in sorted(imports[fname]):
                print item,
            print

if __name__ == '__main__':
    main()

    
</source>

* Do gromadzenia nazw importowanych modułów wykorzystuję zbiory, ponieważ nie interesuje mnie, ile razy który moduł był importowany, tylko '''czy''' był;
* polecenia postaci <code>import mod1, mod2 as alias, mod3...</code> analizuję w dwóch etapach, za pomocą drugiego i trzeciego wyrażenia regularnego;
* opcja ''--verbose'' (równoważnie, ''-v'') powoduje wypisanie, oprócz listy nazw modułów importowanych we wszystkich plikach wymienionych na linii poleceń łącznie, list osobno dla poszczególnych plików.
* opcja ''re.MULTILINE'' (w funkcji ''re.compile'') służy temu, by ''^'' i ''$'' pasowały do początku i końca linii, a nie jedynie początku i końca całego napisu.

''C.D.N.''