Update Trennstile und -filter.

[wortliste.git] / skripte / python / edit_tools / wortliste.py

#!/usr/bin/env python
# -*- coding: utf8 -*-
# :Copyright: © 2012 Günter Milde.
# :Licence:   This work may be distributed and/or modified under
#             the conditions of the `LaTeX Project Public License`,
#             either version 1.3 of this license or (at your option)
#             any later  version.
# :Version:   0.1 (2012-02-07)

# wortliste.py
# ************
# ::

"""Hilfsmittel für die Arbeit mit der `Wortliste`"""

# .. contents::
#
# Die hier versammelten Funktionen und Klassen dienen der Arbeit an und
# mit der freien `Wortliste der deutschsprachigen Trennmustermannschaft`_
# (wortliste_).
#
# Abhängigkeiten
# ==============
#
# Python 2.7 mit den Standardbibliotheken::

import difflib
import re
import codecs
import unicodedata
import copy
import itertools
import sys
from collections import defaultdict  # Wörterbuch mit Default

# WordFile
# ========
#
# Klasse zum Lesen und Schreiben der `Wortliste`::

class WordFile(file):

    encoding = 'utf8'

# Initialisierung
# ----------------
#
# Das Argument ``format`` ist "f8", "f5", oder "auto":
#
#    :f8: das originale, maximal 8-spaltige Wortlisten-Format (Langform_),
#    :f5: das neue, maximal 5-spaltige Wortlisten-Format (Kurzform_),
#    :auto: bestimme das Format automatisch.
#
# ::

    def __init__(self, name, mode='r', encoding='utf8', format='f8'):

        self.encoding = encoding
        file.__init__(self, name, mode)
        # Dateiformat bestimmen und die Eintrags-Klasse setzen:
        self.set_entry_class(format)

# Klasse zum Verarbeiten der Zeilen setzen.
# Mit self.format == "auto", werden die ersten Zeilen der Datei untersucht
# und der Pointer zurückgesetzt.
#
# ::

    def set_entry_class(self, format, search_limit=1000):

        assert(format in ('f8', 'f5', 'auto'))
        self.format = format # default
        self.entry_class = WordEntry # default
        n = 0 # Zählindex

        # Format anhand des Dateiinhalts bestimmen:
        if format == 'auto':
            for e in self:
                # nur ein Feld oder erstes Feld leer oder mit Trennzeichen:
                if len(e) == 1 or e and re.search(u'[-=<>]', e[0]):
                    self.format = 'f5'
                    break
                # mehr als 5 Felder: 8-Felder-Format (Langform)
                elif len(e) > 5:
                    self.format = 'f8'
                    break
                if n > search_limit:
                    break
                n += 1
        if self.format == 'f5':
            self.entry_class = ShortEntry

        self.seek(0)            # Dateizeiger zurücksetzen


# Iteration
# ---------
#
# Die spezielle Funktion `__iter__` wird aufgerufen wenn über eine
# Klasseninstanz iteriert wird.
# Sie liefert einen Iterator über die "geparsten" Zeilen (Datenfelder)
# ::

    def __iter__(self):
        entry_class = self.entry_class
        while True:
            line = self.next().rstrip().decode(self.encoding)
            yield entry_class(line)


# asdict()
# --------
#
# Gib ein `dictionary` (assoziatives Array) mit ungetrenntem Wort als
# Schlüssel (`key`) und den Datenfeldern als `value` zurück::

    def asdict(self):
        words = {}
        for entry in self:
            key = entry.key()
            if key == u'#': # reiner Kommentar
                try:
                    words[u'#'].append(self.comment)
                except KeyError:
                    words[u'#'] = self.comment
            else:
                words[key] = entry
        return words

# writelines()
# ------------
#
# Schreibe eine Liste von `unicode` Strings (Zeilen ohne Zeilenendezeichen)
# in die Datei `destination`::

    def writelines(self, lines, destination, encoding=None):
        outfile = codecs.open(destination, 'w',
                              encoding=(encoding or self.encoding))
        outfile.writelines(lines)

# write_entries()
# ---------------
#
# Schreibe eine Liste von Einträgen (WordEntry_ oder ShortEntry_ Objekten) in
# die Datei `destination`::

    def write_entries(self, wortliste, destination, encoding=None):
        lines = (unicode(entry) for entry in wortliste)
        self.writelines(lines, destination, encoding)


# WordEntry
# =========
#
# Klasse für Einträge (Zeilen) der Wortliste_ in Langform_.
# Jede Zeile enthält einen Eintrag mit durch Semikolon „;“
# getrennten Feldern.
#
# Beispiel:
#
# >>> from wortliste import WordEntry
#
# >>> aalbestand = WordEntry(u'Aalbestand;Aal=be<stand # Test')
# >>> print aalbestand
# Aalbestand;Aal=be<stand # Test
#
# .. _Langform:
# .. _8-Spalten-Format:
#
# Bedeutung der Felder im 8-Spalten-Format (Langform):
#
# 1. Wort ungetrennt
# 2. Wort mit Trennungen, falls für alle Varianten identisch,
#    anderenfalls leer
# 3. falls Feld 2 leer, Trennung nach traditioneller Rechtschreibung
# 4. falls Feld 2 leer, Trennung nach reformierter Rechtschreibung (2006)
# 5. falls Feld 2 leer, Trennung für Wortform, die entweder in
#    der Schweiz oder mit Großbuchstaben oder Kapitälchen benutzt wird
#    und für traditionelle und reformierte Rechtschreibung identisch ist
# 6. falls Feld 5 leer, Trennung für Wortform, die entweder in
#    der Schweiz oder mit Großbuchstaben oder Kapitälchen benutzt wird,
#    traditionelle Rechtschreibung
# 7. falls Feld 5 leer, Trennung für Wortform, die entweder in
#    der Schweiz oder mit Großbuchstaben oder Kapitälchen benutzt wird,
#    reformierte Rechtschreibung (2006)
# 8. falls Feld 5 leer, Trennung nach (deutsch)schweizerischer
#    Rechtschreibung; insbesondere Wörter mit "sss" gefolgt von
#    einem Vokal, die wie andere Dreifachkonsonanten gehandhabt wurden
#    (also anders, als der Duden früher vorgeschrieben hat), z.B.
#    "süssauer"
#
# ::

class WordEntry(list):

# Argumente
# ---------
#
# feldnamen, feldindizes
# ~~~~~~~~~~~~~~~~~~~~~~
#
# Benennung der Felder mit Sprachkürzeln (Tags nach [BCP47]_).
# (Die Zählung der Indizes beginnt in Python bei 0.)::

    feldnamen = ('key', 'de', 'de-1901', 'de-1996', 'de-x-versal',
                 'de-1901-x-versal', 'de-1996-x-versal', 'de-CH-1901')

    feldindizes = {
        'key':              0, # Schlüssel
        'de':               1, # Deutsch, allgemeingültig
        'de-1901':          2, # "traditionell" (nach Rechtschreibreform 1901)
        'de-1996':          3, # reformierte Reformschreibung (1996)
        'de-x-GROSS':       4, # ohne ß (Schweiz oder versal) allgemein
        'de-x-versal':      4, # Alias
        # 'de-CH':          4, # Alias
        'de-1901-x-GROSS':  5, # ohne ß (Schweiz oder versal) "traditionell"
        'de-1901-x-versal': 5, # Alias
        'de-1996-x-GROSS':  6, # ohne ß (Schweiz oder versal) "reformiert"
        'de-1996-x-versal': 6, # Alias
        # 'de-CH-1996':     6, # Alias
        'de-CH-1901':       7, # ohne ß (Schweiz) "traditionell" ("süssauer")
        }


# ersatzfelder
# ~~~~~~~~~~~~
#
# Bei der Auswahl eines Wortes in einer Rechtschreibvariante werden
# "generische" Felder gewählt, falls das "Originalfeld" fehlt. Die folgenden
# Tupel listen die Ersatzfelder für das ensprechende Originalfeld.
#
# Bsp: Ersatz-Felder für 'de-CH-1901':
#
# >>> for i in WordEntry.ersatzfelder[WordEntry.feldindizes['de-CH-1901']]:
# ...     print WordEntry.feldnamen[i]
# de-1901-x-versal
# de-x-versal
# de-1901
# de
#
# ::

    #               Ersatzindizes  Index  Nr  Name
    ersatzfelder = (tuple(),       # 0    1   key
                    tuple(),       # 1    2   'de'
                    (1,),          # 2    3   'de-1901'
                    (1,),          # 3    4   'de-1996'
                    (1,),          # 4    5   'de-x-versal'
                    (4, 2, 1),     # 5    6   'de-1901-x-versal'
                    (4, 3, 1),     # 6    7   'de-1996-x-versal'
                    (5, 4, 2, 1),  # 7    8   'de-CH-1901'
                   )


# comment
# ~~~~~~~
#
# Kommentar, Vorgabe ist ein leerer String::

    comment = u''


# Initialisierung
# ---------------
# ::


    def __init__(self, line, delimiter=u';'):

        self.delimiter = delimiter

# eventuell vorhandenen Kommentar abtrennen und speichern::

        if u'#' in line:
            line, comment = line.split(u'#', 1)
            self.comment = comment.strip()
            line = line.rstrip()
            # print (line, self.comment)

        if not line: # kein Inhalt
            return

# Zerlegen in Datenfelder, in Liste eintragen::

        for field in line.split(delimiter):
            if field.startswith(u'-'):
                self.append(u'')
            else:
                self.append(field)


# Rückverwandlung in String
# -------------------------
#
# Erzeugen eines Eintrag-Strings (ohne Zeilenendezeichen) aus der Liste der
# Datenfelder und dem Kommentar
#
# unicode()
# ~~~~~~~~~
#
# >>> unicode(aalbestand)
# u'Aalbestand;Aal=be<stand # Test'
#
# >>> grse = WordEntry(u'Grüße;Grü-ße')
# >>> print unicode(grse)
# Grüße;Grü-ße
#
# >>> leerkommentar = WordEntry(u'# Testkommentar ')
# >>> leerkommentar, unicode(leerkommentar)
# (WordEntry(u'# Testkommentar'), u'# Testkommentar')
#
# ::

    def __unicode__(self):
        # Nummerieren leerer Felder:
        fields = [field or u'-%d-' % (i+1)
                  for (i, field) in enumerate(self)]
        line = u';'.join(fields)
        if self.comment:
            line += u' # ' + self.comment
            if not self:
                line = line.lstrip()
        return line

# __str__()
# ~~~~~~~~~
# >>> print type(str(grse)), str(grse).decode('utf8')
# <type 'str'> Grüße;Grü-ße
#
# ::

    def __str__(self):
        return unicode(self).encode('utf8')

# __repr__()
# ~~~~~~~~~~
# >>> print type(repr(grse)), repr(grse).decode('utf8')
# <type 'str'> WordEntry(u'Grüße;Grü-ße')
#
# ::

    def __repr__(self):
        s = u'%s(u\'%s\')' % (self.__class__.__name__, self)
        return s.encode('utf8')

# lang_index()
# ------------
#
# Bestimme den Index des zur Sprachvariante gehörenden Datenfeldes unter
# Verwendung der Ersatzfelder:
#
# >>> aalbestand.lang_index('de')
# 1
# >>> aalbestand.lang_index('de-1901')
# 1
# >>> aalbestand.lang_index('de-1996')
# 1
# >>> aalbestand.lang_index('de-x-versal')
# 1
# >>> aalbestand.lang_index('de-1901-x-versal')
# 1
# >>> aalbestand.lang_index('de-1996-x-versal')
# 1
# >>> abbeissen = WordEntry(
# ...     u'abbeissen;-2-;-3-;-4-;-5-;ab<bei-ssen;ab<beis-sen;ab<beis-sen')
# >>> print abbeissen.lang_index('de')
# None
# >>> print abbeissen.lang_index('de-x-versal')
# None
# >>> abbeissen.lang_index('de-1901-x-versal')
# 5
# >>> abbeissen.lang_index('de-1996-x-versal')
# 6
# >>> abbeissen.lang_index('de-CH-1901')
# 7
# >>> urlaubstipp = WordEntry(u'Urlaubstipp;-2-;-3-;Ur<laubs=tipp')
# >>> print urlaubstipp.lang_index('de')
# None
# >>> print urlaubstipp.lang_index('de-1901')
# None
# >>> print urlaubstipp.lang_index('de-1996')
# 3
# >>> print urlaubstipp.lang_index('de-x-versal')
# None
# >>> print urlaubstipp.lang_index('de-1901-x-versal')
# None
#
# ::

    def lang_index(self, lang):

        if lang not in self.feldindizes:
            raise ValueError('Sprachvariante "%s" nicht in %s'
                             % (lang, self.feldindizes.keys()))

# Einfacher Fall: eine allgemeine Schreibweise::

        if len(self) == 2:
            if u'ß' in self[0] and ('CH' in lang or 'versal' in lang):
                return None
            else:
                return 1

# Spezielle Schreibung::

        try:
            i = self.feldindizes[lang]
            feld = self[i]
        except IndexError:
            if lang == 'de-CH-1901':
                return self.lang_index('de-1901-x-versal')
            # Allgemeine Schweiz/versal Schreibung:
            if i > 4 and len(self) == 5:
                return 4
            # versal == normal (kein sz):
            if len(self) == 4 and u'ß' not in self[0]:
                if lang in ('de-CH-1901', 'de-1901-x-versal'):
                    return self.lang_index('de-1901')
                elif lang in ('de-CH-1996', 'de-1996-x-versal'):
                    return self.lang_index('de-1996')
            return None  # Feld nicht vorhanden

        if not feld:  # leeres Feld
            return None

        return i

# key()
# -----
#
# Gib einen Schlüssel (ungetrenntes Wort) zurück.
#
# Bei Einträgen im Langform_ ist der Schlüssel gleich dem Inhalt des ersten
# Feldes. Die Funktion dient zur Kompatibilität mit ShortEntry_.
#
# >>> print WordEntry(u'Fluss;Quatsch').key()
# Fluss
# >>> print WordEntry(u'Dreß;-1-;Dreß;-3-').key()
# Dreß
#
# Das `lang` Argument wird ignoriert, da der Schlüssel (im Gegensatz zur
# Kurzform_) stets eindeutig ist:
#
# >>> print WordEntry(u'Dreß;-1-;Dreß;-3-').key('de-1996')
# Dreß
#
# Der Schlüssel eines leeren Eintrags ist ein leerer String, der eines leeren
# Kommentars das Kommentarzeichen:
#
# >>> WordEntry(u'').key(), WordEntry(u'# toller Kommentar').key()
# (u'', u'#')
#
# ::

    def key(self, lang=None):
        """Gib den Schlüssel (ungetrenntes Wort) zurück."""
        try:
            return self[0]
        except IndexError: # reiner Kommentar oder leerer Eintrag
            if self.comment:
                return u'#'
            return u''


# getitem()
# ---------
#
# Gib Feld ``i`` oder Ersatzfeld zurück.
# ::

    def getitem(self, i):
        """Return item ``i`` or a subsititute"""
        try:
            return self[i]
        except IndexError: # Feld i nicht vorhanden
            pass
        # Ersatzregeln anwenden
        for _i in self.ersatzfelder[i]:
            try:
                word = self[_i]
            except IndexError: # Feld i nicht vorhanden
                continue       # nächsten `tag` versuchen
            # Spezialfall: in Versalschreibung ungültige Ersatz-Wörter
            if i >= 4 and _i <4 and u'ß' in word:
                return u''
            return word
        return u''

# .. _WordEntry.get():
#
# get()
# -----
#
# Trennmuster für eine Sprachvariante ausgeben:
#
# >>> aalbestand.get('de')
# u'Aal=be<stand'
# >>> aalbestand.get('de-1901')
# u'Aal=be<stand'
# >>> aalbestand.get('de-1996')
# u'Aal=be<stand'
# >>> aalbestand.get('de-x-versal')
# u'Aal=be<stand'
# >>> aalbestand.get('de-1901-x-versal')
# u'Aal=be<stand'
# >>> aalbestand.get('de-1996-x-versal')
# u'Aal=be<stand'
# >>> aalbestand.get('de-CH-1901')
# u'Aal=be<stand'
#
# >>> weste = WordEntry(u'Weste;-2-;We-ste;Wes-te')
# >>> weste.get('de')
# u''
# >>> weste.get('de-1901')
# u'We-ste'
# >>> weste.get('de-1996')
# u'Wes-te'
#
# >>> abbeissen.get('de')
# u''
# >>> abbeissen.get('de-x-versal')
# u''
# >>> abbeissen.get('de,de-x-versal')
# u''
# >>> abbeissen.get('de-1901-x-versal')
# u'ab<bei-ssen'
# >>> abbeissen.get('de,de-1901,de-1901-x-versal')
# u'ab<bei-ssen'
# >>> abbeissen.get('de-CH-1901')
# u'ab<beis-sen'
#
# ::

    def get(self, tags):
        for lang in tags.split(','):
            word = self.getitem(self.feldindizes[lang])
            if word:
                break
        else:
            return u''
        return word


# set()
# -----
#
# Trennmuster für Sprachvariante setzen:
#
# >>> abbeissen.set('test', 'de-1901-x-versal')
# >>> print abbeissen
# abbeissen;-2-;-3-;-4-;-5-;test;ab<beis-sen;ab<beis-sen
#
# >>> abbeissen.set('test', 'de-1901')
# Traceback (most recent call last):
# ...
# IndexError: kann kein leeres Feld setzen
#
# >>> abbeissen.set('test', 'de-1901,de-1901-x-versal')
# >>> print abbeissen
# abbeissen;-2-;-3-;-4-;-5-;test;ab<beis-sen;ab<beis-sen
#
# ::

    def set(self, word, tags):
        for lang in tags.split(','):
            i = self.lang_index(lang)
            if i is None:
                continue
            if word is None:
                word = u''
            self[i] = word
            return
        raise IndexError, "kann kein leeres Feld setzen"

# setitem()
# ---------
#
# Feld ``i`` setzen:
#
# >>> entry = WordEntry(u'test;test')
# >>> entry.setitem(4, u's-x')
# >>> print entry
# test;test;-3-;-4-;s-x
# >>> entry.setitem(3, u'sz')
# >>> print entry
# test;test;-3-;sz;s-x
#
# ::

    def setitem(self, i, word):
        while len(self) < i+1:
            self.append(u'')
        self[i] = word


# complete()
# ----------
#
# Alle Felder setzen:
#
# >>> print WordEntry(u'Ruhe;Ru-he').completed()
# Ruhe;Ru-he;Ru-he;Ru-he;Ru-he;Ru-he;Ru-he;Ru-he
#
# >>> print str(aalbestand), len(aalbestand)
# Aalbestand;Aal=be<stand # Test 2
# >>> print aalbestand.completed()
# Aalbestand;Aal=be<stand;Aal=be<stand;Aal=be<stand;Aal=be<stand;Aal=be<stand;Aal=be<stand;Aal=be<stand # Test
#
# >>> auffrass = WordEntry(u'auffrass;-2-;-3-;-4-;auf-frass')
# >>> print auffrass.completed()
# auffrass;-2-;-3-;-4-;auf-frass;auf-frass;auf-frass;auf-frass
#
# >>> fresssack= WordEntry(u'Fresssack;-2-;-3-;Fress=sack;Fress=sack')
# >>> print fresssack.completed()
# Fresssack;-2-;-3-;Fress=sack;Fress=sack;Fress=sack;Fress=sack;Fress=sack
#
# >>> line = u'Flussschiffahrt;-2-;-3-;-4-;-5-;Fluss=schi{ff/ff=f}ahrt;-7-'
# >>> print WordEntry(line).completed()
# Flussschiffahrt;-2-;-3-;-4-;-5-;Fluss=schi{ff/ff=f}ahrt;-7-;Fluss=schi{ff/ff=f}ahrt
#
# >>> line = u'Ackerstraße;-2-;A{ck/k-k}er=stra-ße;Acker=stra-ße'
# >>> ackerstrasse = WordEntry(line).completed()
# >>> print unicode(ackerstrasse)
# Ackerstraße;-2-;A{ck/k-k}er=stra-ße;Acker=stra-ße;-5-;-6-;-7-;-8-
#
# ::

    def complete(self):
        for i in range(len(self),8):
            self.append(self.getitem(i))

# .. _WordEntry.completed():
#
# completed()
# -----------
#
# Gib eine vervollständigte Kopie des Eintrags zurück.
# ::

    def completed(self):
        """Return expanded copy of self."""
        neu = copy.copy(self)
        neu.complete()
        return neu

# .. _ShortEntry.prune():
#
# prune()
# -------
#
# Eintrag kürzen.
#
# Felder für Sprachvarianten zusammenfassen, wenn gleich:
#
# >>> aalbestand.prune()
# >>> print aalbestand
# Aalbestand;Aal=be<stand # Test
# >>> auffrass.prune()
# >>> print auffrass
# auffrass;-2-;-3-;-4-;auf-frass
# >>> entry = WordEntry(u'distanziert;-2-;di-stan-ziert;di-stan-ziert')
# >>> entry.prune()
# >>> print entry
# distanziert;di-stan-ziert
# >>> entry = WordEntry(u'Gauss;-2-;Gauss;Gauss;Gauss')
# >>> entry.prune()
# >>> print entry
# Gauss;Gauss
# >>> fresssack.prune()
# >>> print fresssack
# Fresssack;-2-;-3-;Fress=sack;Fress=sack
#
# >>> masse = WordEntry(u'Masse;Mas-se;Mas-se;Mas-se;Mas-se;Mas-se;Mas-se;Mas-se')
# >>> masse.prune()
# >>> print masse
# Masse;Mas-se
#
# Aber nicht, wenn die Trennstellen sich unterscheiden:
#
# >>> abenddienste = WordEntry(
# ...    u'Abenddienste;-2-;Abend=dien-ste;Abend=diens-te')
# >>> abenddienste.prune()
# >>> print abenddienste
# Abenddienste;-2-;Abend=dien-ste;Abend=diens-te
# >>> ackerstrasse.prune()
# >>> print unicode(ackerstrasse)
# Ackerstraße;-2-;A{ck/k-k}er=stra-ße;Acker=stra-ße
# >>> entry = WordEntry(
# ...    u'Schlammmasse;-2-;-3-;Schlamm=mas-se;-5-;-6-;Schlamm=mas-se;-8-')
# >>> entry.prune()
# >>> print entry
# Schlammmasse;-2-;-3-;Schlamm=mas-se
# >>> entry = WordEntry(
# ...    u'Flussschiffahrt;-2-;-3-;-4-;-5-;Fluss=schi{ff/ff=f}ahrt;-7-')
# >>> entry.prune()
# >>> print entry
# Flussschiffahrt;-2-;-3-;-4-;-5-;Fluss=schi{ff/ff=f}ahrt;-7-
#
# ::

    def prune(self):
        if len(self) == 8:
            if self[7] == self[5]: # de-CH-1901 gleich versal-1901
                self.pop()
        if len(self) == 7:
            if self[6] == self[5]:
                self[4] = self[5] # umschreiben auf versal-allgemein
                self.pop()
                self.pop()
            elif (not(self[4] or self[5] or self[6])
                  or self[5] == self[2] and self[6] == self[3]):
                # alle leer oder ohne ß-Ersetzung
                self.pop()
                self.pop()
                self.pop()
        if len(self) == 5:
            if not self[4]:
                self.pop()
            elif self[1] == self[4]: # de-x-versal == de
                self.pop()
                self.pop()
                self.pop()
            elif self[2] == self[3] == self[4]:
                self[1] = self[2] # Umschreiben auf de (allgemein)
                self.pop()
                self.pop()
                self.pop()
        if len(self) == 4:
            if self[3] == self[2]: # de-1996 == de-1901
                self[1] = self[2] # Umschreiben auf de (allgemein)
                self.pop()
                self.pop()

        if len(self) > 6:
            self[4] = u''
        if len(self) > 2:
            self[1] = u''


# pruned()
# -----------
#
# Gib eine gekürzte Kopie des Eintrags zurück.
# ::

    def pruned(self):
        """Return pruned copy of self."""
        neu = copy.copy(self)
        neu.prune()
        return neu

# .. _WordEntry.merge():
#
# merge()
# -------
#
# Einträge zusammenfassen:
#
# >>> entry = WordEntry(u'Dienste;-2-;Dien-ste')
# >>> entry.merge(WordEntry(u'Dienste;-2-;-3-;diens-te'))
# >>> print unicode(entry)
# Dienste;-2-;Dien-ste;Diens-te
# >>> entry = WordEntry(u'Abenddress;Abend=dress')
# >>> entry.merge(WordEntry(u'Abenddress;-2-;-3-;-4-;Abend=dress'))
# >>> print unicode(entry)
# Abenddress;Abend=dress
# >>> entry = WordEntry(u'Gauss;Gauss')
# >>> entry.merge(WordEntry(u'Gauss;-2-;-3-;-4-;Gauss'))
# >>> print unicode(entry)
# Gauss;Gauss
# >>> masse.merge(WordEntry(u'masse;-2-;-3-;-4-;-5-;Ma-sse;Mas-se;Mas-se'),
# ...             allow_alternatives=True)
# >>> print masse
# Masse;-2-;Mas-se;Mas-se;-5-;Ma[s-/-s]se;Mas-se;Mas-se
#
# ::

    def merge(self, other, allow_alternatives=False, prune=True,
              merge_comments=False, start=0, stop=None):
        self.complete()
        other.complete()
        islower = self.key().islower()
        conflict = False
        # `stop=None` oder `stop=0` bedeutet "keine Obergrenze".
        stop = stop or len(self)
        for i in range(start, stop):
            o_i = other[i]
            if not o_i:
                continue
            if islower != o_i.islower():
                o_i = toggle_case(o_i)
            s_i = self[i]
            if not s_i:
                self[i] = o_i
                # other[i] = u''
            # elif s_i == o_i:
            #     other[i] = u''
            elif s_i != o_i:
                if s_i.lower() == o_i.lower():
                    self[i] = toggle_case(o_i)
                elif allow_alternatives:
                    self[i] = alternatives(s_i, o_i) #u'[%s/%s]' % (s_i, o_i)
                    # o_i = u''
                else:
                    conflict = True
        if merge_comments and not conflict and self.comment != other.comment:
            if allow_alternatives and self.comment and other.comment:
                self.comment += u' / ' + other.comment
            else:
                self.comment = self.comment or other.comment

        if conflict:
            raise AssertionError(u'Merge Error:\n %s\n %s'
                                 % (unicode(self), unicode(other)))

        if prune:
            other.prune()
            self.prune()


# regelaenderungen()
# ------------------
#
# Teste Felder auf Konsistenz mit den Regeländerungen der Orthographiereform
# 1996, ändere Unstimmigkeiten `in place`.
#
# Die neuere Funktion `ableitung1901()`_, deckt mehr Ausnahmen ab aber
# funktioniert nur in eine Richtung.
#
# Falls ein generisches Feld von Änderung betroffen ist, schreibe die
# korrekten Trennungen in die spezifischen Felder.
#
# >>> entry = WordEntry(u'Würste;Wür-ste')
# >>> entry.regelaenderungen()
# >>> print unicode(entry)
# Würste;-2-;Wür-ste;Würs-te
# >>> entry = WordEntry(u'Würste;Würs-te')
# >>> entry.regelaenderungen()
# >>> print unicode(entry)
# Würste;-2-;Wür-ste;Würs-te
# >>> entry = WordEntry(u'Hecke;He-cke')
# >>> entry.regelaenderungen()
# >>> print unicode(entry)
# Hecke;-2-;He{ck/k-k}e;He-cke
# >>> entry = WordEntry(u'Ligusterhecke;Ligu-ster=he{ck/k-k}e')
# >>> entry.regelaenderungen()
# >>> print unicode(entry)
# Ligusterhecke;-2-;Ligu-ster=he{ck/k-k}e;Ligus-ter=he-cke
#
# Bei Änderungen der Schreibung wird das entsprechende Feld ausgekreuzt:
#
# >>> entry = WordEntry(u'Hass;Hass')
# >>> entry.regelaenderungen()
# >>> print unicode(entry)
# Hass;-2-;-3-;Hass;Hass
# >>> entry = WordEntry(u'fasst;fasst')
# >>> entry.regelaenderungen()
# >>> print unicode(entry)
# fasst;-2-;-3-;fasst;fasst
# >>> entry = WordEntry(u'Missbrauch;Miss<brauch')
# >>> entry.regelaenderungen()
# >>> print unicode(entry)
# Missbrauch;-2-;-3-;Miss<brauch;Miss<brauch
# >>> entry = WordEntry(u'schlifffest;schliff=fest')
# >>> entry.regelaenderungen()
# >>> print unicode(entry)
# schlifffest;-2-;-3-;schliff=fest
#
# Bei gleicher, nicht betroffener Trennung werden Felder zusammengefasst:
#
# >>> entry = WordEntry(u'austoben;-2-;aus<to-ben;aus<to-ben')
# >>> entry.regelaenderungen()
# >>> print unicode(entry)
# austoben;aus<to-ben
#
# Achtung: nicht narrensicher -- Ausnahmen und Mehrdeutigkeiten werden nicht
# alle erkannt:
#
# >>> entry = WordEntry(u'Boss;Boss # engl.') # korrekt
# >>> entry.regelaenderungen()
# >>> print unicode(entry)
# Boss;Boss # engl.
#
# >>> entry = WordEntry(u'Ästhesie;Äs-the-sie') # Trennung von "sth" erlaubt
# >>> entry.regelaenderungen()
# >>> print unicode(entry)
# Ästhesie;Äs-the-sie
#
# >>> entry = WordEntry(u'Fluß;Fluß') # in de-1996 nur Fluss
# >>> entry.regelaenderungen()
# >>> print unicode(entry)
# Fluß;Fluß
#
# ::

    def regelaenderungen(self):
        wort01 = self.get('de-1901')
        wort96 = self.get('de-1996')
        w_versal = None

        if wort01 is None or wort96 is None or 'engl.' in self.comment:
            return

        # Trennregeländerungen:

        # Trennung von ck:
        wort01 = wort01.replace(u'-ck', u'{ck/k-k}')
        wort96 = wort96.replace(u'{ck/k-k}', u'-ck')

        # Trenne nie st:
        wort01 = re.sub(u'(?<!s)s-t(?!h)', u'-st', wort01)
        wort96 = wort96.replace(u'-st', u's-t')

        # kein Schluss-ss und sst in de-1901 (ungetrenntes "ss" nur in Ausnahmen)
        # aber: 'ßt' und Schluß-ß auch in de-1996 möglich (langer Vokal)
        if u'ss' in wort01:
            w_versal = wort01
            wort01 = None

        # Dreikonsonantenregel:
        if wort01 and re.search(ur'(.)\1=\1', wort01):
            wort01 = None

        # Speichern:
        if wort01 == wort96: # keine Regeländerung im Wort
            if len(self) > 2:
                self.prune()
            return

        if wort01 is None:
            self.extend( ['']*(4-len(self)) )
            self[1] = u''
            self[2] = u''
            self[3] = wort96
        else:
            self.extend( ['']*(4-len(self)) )
            self[1] = u''
            self[2] = wort01
            self[3] = wort96
        if w_versal:
            self.append(w_versal)


# ShortEntry
# ==========
#
# Klasse für Einträge (Zeilen) der Wortlisten im `5-Felder-Format`_ (Kurzform).
#
# ::

class ShortEntry(WordEntry):
    """Entry of the German hyphenation database file (5 fields)."""

# .. _Kurzform:
#
# 5-Felder-Format
# ---------------
#
# Ein vollständiger Eintrag enthält fünf, durch Semikolon getrennte, Felder
# für die Sprachvarianten `de`, `de-1901`, `de-CH`, `de-1901-x-versal` und
# `de-CH-1901` (Tags nach [BCP47]_).
#
# Jedes Feld enthält ein Wort mit Kennzeichnung der Trennstellen im Format
# der `Wortliste der deutschsprachigen Trennmustermannschaft`_, z.B.
# ``Pro<zent=zah-len``.
#
# Felder können weggelassen werden, wenn sich der Inhalt aus einem
# allgemeineren Feld gewinnen lässt (siehe `Ersatzregeln`_).
#
#
# Feldbelegung
# ~~~~~~~~~~~~
#
# Die Felder beschreiben die Schreibung und Trennung eines Wortes gemäß
# der Sprachvarianten:
#
# 1. `de`: `aktuelle Rechtschreibung`_ wie sie in Deutschland und Österreich
#    angewendet wird.
#
#    Beispiele: ``Diens-te``, ``ba-cken``, ``Grü-ße``, ``Schluss=satz``
#
# 2. `de-1901`: `traditionelle Rechtschreibung`_ wie sie in Deutschland und
#    Österreich von 1901 bis 1996 gültig war.
#
#    Beispiele: ``Dien-ste``, ``ba{ck/k-k}en``, ``Grü-ße``, ``Schluß=satz``
#
# 3. `de-CH` oder `de-x-versal`: aktuelle Rechtschreibung wie sie in der
#    Schweiz und bei ß-Ersatzschreibung angewendet wird.
#
#    Beispiele: ``ba-cken``, ``Grüs-se``, ``Schluss=satz``
#
# 4. `de-1901-x-versal`: traditionelle Rechtschreibung mit
#    ß-Ersatzschreibung wie sie in Deutschland und Österreich
#    angewendet wurde (keine Trennung von „ss“ als Ersatz für „ß“).
#
#    Beispiele: ``ba{ck/k-k}en``, ``Grü-sse``, ``Schluss=satz``
#
# 5. `de-CH-1901`: traditionelle Rechtschreibung wie sie in der Schweiz
#    angewendet wurde (Trennung von „ss“ auch wenn es für „ß“ steht aber
#    keine Dreikonsonantenregel für „ss=s“).
#
#    Beispiele: ``ba{ck/k-k}en``, ``Grüs-se``, ``Schluss=satz``
#
#
# Ersatzregeln
# ~~~~~~~~~~~~
#
# Feld 1 (`de`) ist ein Pflichtfeld, die anderen Felder können weggelassen
# werden, wenn sich der Inhalt über regelmäßige Transformationen_ aus einem
# anderen Feld gewinnen lässt:
#
# ==================== ============= =======================
# Feld                 Quelle        Transformation
# ==================== ============= =======================
# 1 de
# 2 de-1901            1 de          „Rechtschreibreversion_“
# 3 de-CH              1 de          SZ-Ersatz_
# 4 de-1901-x-versal   2 de-1901     SZ-Ersatz_
# 5 de-CH-1901         2 de-1901     SZ-Ersatz_
# ==================== ============= =======================
#
# Die Ersetzung erfolgt rekursiv (d.h. wenn Feld 2 nicht gegeben ist, können
# die Felder 4 und 5 aus Feld 1 mit „Rechtschreibreversion_“ und SZ-Ersatz_
# bestimmt werden).
#
# Wenn ein Eintrag in einer Sprachvariante leer bleiben soll, muss das
# zugehörige Feld entsprechend markiert („ausgekreuzt“) werden.
# (Da die ß-Ersatzschreibung für alle Wörter definiert ist, ist in einer
# vollständigen Liste das Auskreuzen der Spalten 3…5 nicht erforderlich.)
#
# Beispiele: ``-1-;de<pla-ziert``, ``auf<wän-dig;-2-;``.
#
#
# Implementiert in `ShortEntry.getitem()`_.
#
#
# Rechtschreibreversion
# """""""""""""""""""""
#
# Überführung eines Wortes in die Sprachvariante de-1901 durch
# Anwendung der mit der Rechtschreibreform 1996 entfallenen Regeln:
#
# st-Trennung_:
#   Trenne nie "st". (Aber "s-th" ist trennbar.)
# ck-Trennung_:
#   Trenne "ck" als "k-k".
# Schluss-ss_:
#   "ß", "ßt" und "ßl" statt "ss", "sst" und "ssl" am Silbenende.
# Dreikonsonantenregel_:
#   Von drei gleichen Konsonanten vor einem Selbstlaut entfällt einer,
#   taucht aber bei Worttrennung wieder auf.
#
# Abweichende Änderungen müssen als Ausnahmen explizit erfasst werden.
#
# Implementiert in `ableitung1901()`_.
#
# SZ-Ersatz
# """""""""
# Ersetze 'ß' mit 'ss', trenne je nach Sprachvarietät (siehe Feldbelegung_).
#
# Implementiert in `versalschreibung()`_.
#
#
#
# Beispiel
# --------
#
# Durch die Ersatzregeln reicht für die meisten Einträge die Angabe des ersten
# Feldes, z.B.
#
# >>> from wortliste import ShortEntry
# >>> entry = ShortEntry(u'Pass=stra-ße')
#
# Eintrag vervollständigen mit `ShortEntry.complete()`_:
#
# >>> entry.complete(); print unicode(entry)
# Pass=stra-ße;Paß=stra-ße;Pass=stras-se;Pass=stra-sse;Pass=stras-se
#
# Eintrag kürzen mit `ShortEntry.prune()`_:
#
# >>> entry.prune(); print unicode(entry)
# Pass=stra-ße
#
# Wort mit Unregelmäßigkeiten:
#
# >>> entry = ShortEntry(u'Boss;Boss;Boss;Boss;Boss # en.')
# >>> entry.prune(); print unicode(entry)
# Boss;Boss # en.
#
#
# Argumente
# ---------
#
# feldnamen
# ~~~~~~~~~
#
# Tupel der Sprachbezeichner für die Felder im 5-Felder-Format_::

    feldnamen = ("de", "de-1901", "de-CH", "de-1901-x-versal", "de-CH-1901")

# feldindizes
# ~~~~~~~~~~~
#
# Zuordnung von Sprachbezeichnern nach [BCP47]_ zu den Feldern.
#
# In Python beginnt die Indexzählung mit Null::

    feldindizes = {
        "de":               0, # Deutsch, aktuell
        "de-DE":            0, # Alias
        "de-AT":            0, # Alias
        "de-1996":          0, # Alias
        "de-1996":          0, # Alias
        "de-DE-1996":       0, # Alias
        "de-AT-1996":       0, # Alias
        "de-1901":          1, # traditionell (Reform 1901)
        "de-CH":            2, # ohne ß (Schweiz/versal) aktuell
        "de-x-versal":      2, # Alias
        "de-1996-x-versal": 2, # Alias
        "de-1901-x-versal": 3, # ohne ß (versal) traditionell
        "de-CH-1901":       4, # ohne ß (Schweiz) traditionell
        }

# Achtung: die Sprachtags `de` und `de-CH` sind in der Kurzform_ ein Alias für
# die aktuelle Rechtschreibung aber in der Langform_ Bezeichner für separate
# Felder mit allgemeingültigen Trennungen:
#
# >>> print ShortEntry.feldindizes['de-1901'], ShortEntry.feldindizes['de-CH']
# 1 2
# >>> print ShortEntry.feldindizes['de'], ShortEntry.feldindizes['de-1996']
# 0 0
#
# >>> print WordEntry.feldindizes['de'], WordEntry.feldindizes['de-1996']
# 1 3
#
# Schlüssel-Cache
# ~~~~~~~~~~~~~~~
# ::

    _key = None


# Initialisierung
# ---------------
#
# Das Argument `line` ist eine Zeichenkette (`string`, `unicode`) im
# `5-Felder-Format`_ oder eine Instanz der Klasse WordEntry_.
#
# >>> print ShortEntry(u'Diens-te')
# Diens-te
# >>> tpp = ShortEntry(u'Ur<laubs=tipp;-2-')
# >>> print tpp
# Ur<laubs=tipp;-2-
#
# >>> print abenddienste
# Abenddienste;-2-;Abend=dien-ste;Abend=diens-te
# >>> print ShortEntry(abenddienste)
# Abend=diens-te
#
# Achtung: Ein Lang-Eintrag mit nur zwei Feldern kann unregelmäßig sein und
# daher im Kurzformat mehrere Felder benötigen (siehe Tests)
# ::

    def __init__(self, line, delimiter=';', prune=True):

        if isinstance(line, WordEntry):
            self.comment = line.comment  # Kommentar
            self._key = line.getitem(0)  # Schlüssel cachen
            if not line:
                return
            self.append(line.getitem(3)) # Deutsch, aktuell (Reform 1996)
            self.append(line.getitem(2)) # "traditionell" (Reform 1901)
            if len(line) > 4:
                self.append(line.getitem(6)) # ohne ß (Schweiz oder versal) "aktuell"
                self.append(line.getitem(5)) # ohne ß (Schweiz oder versal) "traditionell"
                self.append(line.getitem(7)) # ohne ß (Schweiz) "traditionell" ("süssauer")
            elif u'ß' in self._key: # auskreuzen
                self.append(u'')
                self.append(u'')
                self.append(u'')
        else:
            WordEntry.__init__(self, line, delimiter)

        if prune: # Felder zusammenfassen
            self.prune()

# Tests
# ~~~~~
# >>> drs = unicode(ShortEntry(u'-1-;Dreß'))
# >>> print drs
# -1-;Dreß
# >>> print ShortEntry(u'# Testkommentar')
# # Testkommentar
#
# In der Voreinstellung werden optionale Felder mit `prune()` gekürzt.
# Mit der Option `prune=False` bleiben alle übergebenen Felder erhalten:
#
# >>> print unicode(ShortEntry(u'Fluss;Fluß'))
# Fluss
# >>> print unicode(ShortEntry(u'Fluss;Fluß', prune=False))
# Fluss;Fluß
#
# Wird dem Konstruktor eine WordEntry_-Instanz übergeben, so wird diese in das
# Kurzformat überführt:
#
# >>> print ShortEntry(WordEntry(u'heute;heu-te'))
# heu-te
#
# Bei Ausnahmen von der regelmäßigen Worttrennung werden bei Bedarf
# zusätzliche Spalten belegt:
#
# >>> print ShortEntry(WordEntry(u'Amnesty;Am-nes-ty # en.'))
# Am-nes-ty;Am-nes-ty # en.
# >>> bss = ShortEntry(WordEntry(u'Boss;Boss # engl.'))
# >>> print bss
# Boss;Boss # engl.
#
# Bei Wörtern mit unterschiedlicher Schreibung in den verschiedenen
# Sprachvarianten werden Felder, die im übergebenen `WordEntry` nicht belegt
# sind als leer markiert:
#
# >>> print urlaubstipp
# Urlaubstipp;-2-;-3-;Ur<laubs=tipp
# >>> print ShortEntry(urlaubstipp)
# Ur<laubs=tipp;-2-
# >>> print unicode(ShortEntry(WordEntry(u'Abfalllager;-2-;-3-;Ab<fall=la-ger')))
# Ab<fall=la-ger;-2-
#
# >>> dresz = WordEntry(u'Dreß;-2-;Dreß;-4-')
# >>> print unicode(ShortEntry(dresz))
# -1-;Dreß;-3-;-4-;-5-
# >>> g_ebene = WordEntry(u'Gaußebene;Gauß=ebe-ne')
# >>> print unicode(ShortEntry(g_ebene))
# Gauß=ebe-ne;Gauß=ebe-ne;-3-;-4-;-5-
# >>> print auffrass
# auffrass;-2-;-3-;-4-;auf-frass
# >>> print ShortEntry(auffrass)
# -1-;-2-;auf-frass;auf-frass;auf-frass
# >>> fraesse = WordEntry(u'frässe;-2-;-3-;-4-;-5-;frä-sse;fräs-se;fräs-se')
# >>> frs = ShortEntry(fraesse)
# >>> print unicode(frs)
# -1-;-2-;fräs-se;frä-sse;fräs-se
# >>> loesz = WordEntry(u'Lößboden;Löß=bo-den')
# >>> print unicode(ShortEntry(loesz))
# Löß=bo-den;Löß=bo-den;-3-;-4-;-5-
# >>> loess = WordEntry(u'Lössboden;-2-;-3-;Löss=bo-den;Löss=bo-den')
# >>> print unicode(ShortEntry(loess))
# Löss=bo-den;-2-;Löss=bo-den;Löss=bo-den;Löss=bo-den
#
# >>> print ShortEntry(WordEntry(u'Fussballliga;-2-;-3-;-4-;-5-;-6-;Fuss=ball==li-ga'))
# -1-;-2-;Fuss=ball==li-ga
# >>> print ShortEntry(WordEntry(u'Fussballiga;-2-;-3-;-4-;-5-;Fuss=ba{ll/ll=l}i-.ga;-7-'))
# -1-;-2-;-3-;Fuss=ba{ll/ll=l}i-.ga;Fuss=ba{ll/ll=l}i-.ga
# >>> messignal = WordEntry(u'Messignal;-2-;-3-;-4-;-5-;-6-;-7-;Me{ss/ss=s}i-.gnal')
# >>> print unicode(ShortEntry(messignal))
# -1-;-2-;-3-;-4-;Me{ss/ss=s}i-.gnal
#
# >>> ShortEntry(WordEntry(u'# nur Kommentar'))
# ShortEntry(u'# nur Kommentar')
#
#
# key()
# -----
#
# Gib einen Schlüssel (ungetrenntes Wort) zurück.
#
# Bei Einträgen im Kurzformat ist der Schlüssel nicht eindeutig: durch
# Transformationen_ kann ein Wort in verschiedenen Schreibungen vorkommen.
#
# Standardmäßig wird das erste nichtleere Feld ohne Trennzeichen verwendet:
#
# >>> print ShortEntry(u'Fluss;Fluß').key()
# Fluss
# >>> print ShortEntry(u'-1-;Dreß').key()
# Dreß
#
# Die Auswahl kann über das `lang` Argument gesteuert werden:
#
# >>> print ShortEntry(u'-1-;Dreß').key('de-CH-1901')
# Dress
#
# Der Schlüssel eines leeren Eintrags ist ein leerer String, der eines leeren
# Kommenars das Kommentarzeichen:
#
# >>> ShortEntry(u'').key(), ShortEntry(u'# toller Kommentar').key()
# (u'', u'#')
#
# ::

    def key(self, lang=None):
        """Erstelle einen Schlüssel (ungetrenntes Wort)."""
        if lang:
            return join_word(self.get(lang))
        if self._key:
            return self._key
        for f in self:
            if f:
                self._key = f
                return join_word(f)
        if self.comment:
            return u'#'  # reiner Kommentar
        return u''       # leerer Eintrag


# .. _`ShortEntry.getitem()`:
#
# getitem()
# ---------
#
# Gib Feld `i` zurück. Wende bei Bedarf die Ersatzregeln_ an.
#
# >>> entry = ShortEntry(u'Bu-ße')
# >>> print entry.getitem(1), entry.getitem(2), entry.getitem(4)
# Bu-ße Bus-se Bus-se
#
# >>> entry.getitem(5)
# Traceback (most recent call last):
#     ...
# IndexError: list index out of range
#
# Mit `subsititute=True` wird der Feldinhalt ignoriert und immer nach
# Ersatzregel bestimmt:
#
# >>> entry = ShortEntry(u'Bu-ße;Reue;Bu-sse')
# >>> print entry.getitem(1), entry.getitem(1, substitute=True)
# Reue Bu-ße
#
# ::


    def getitem(self, i, substitute=False):
        """Return item ``i`` or a subsititute"""
        if not substitute:
            try:
                return self[i]
            except IndexError: # Feld i nicht vorhanden
                if not self:
                    raise ValueError('leerer Eintrag')
                if i > 4:
                    raise # maximal 5 Felder im Kurzformat

        # Rekursion: wähle das generischere Feld
        ersatzfelder = (None, 0, 0, 1, 1)
        word = self.getitem(ersatzfelder[i])

        # Bei leerem Feld ("ausgekreuzt") ist keine Transformation nötig
        if not word:
            return u''

        # Rechschreibreform  (s-t, ck, Dreikonsonantenregel)
        if i == 1: # de-1901
            return ableitung1901(word)

        # Versalschreibung:  ß -> ss
        if u'ß' in word:
            word = versalschreibung(word, self.feldnamen[i])
        return word


# get()
# -----
#
# Gib Trennmuster für Sprachvariante zurück (ggf. über Transformationen_).
#
# Beispiele:
#
# ohne Transformation
#
# >>> aalbst = ShortEntry(u'Aal=be<stand # Test')
# >>> aalbst.get('de')
# u'Aal=be<stand'
# >>> aalbst.get('de-1996')
# u'Aal=be<stand'
# >>> aalbst.get('de-1901')
# u'Aal=be<stand'
# >>> aalbst.get('de-x-versal')
# u'Aal=be<stand'
# >>> aalbst.get('de-1901-x-versal')
# u'Aal=be<stand'
# >>> aalbst.get('de-1996-x-versal')
# u'Aal=be<stand'
# >>> aalbst.get('de-CH-1901')
# u'Aal=be<stand'
#
# st und ck:
#
# >>> dst = ShortEntry(u'Diens-te')
# >>> print dst.get('de'), dst.get('de-1901'), dst.get('de-1996')
# Diens-te Dien-ste Diens-te
# >>> print ShortEntry(u'Es-te').get('de-1901')
# Este
# >>> sck = ShortEntry(u'Stre-cke')
# >>> print sck.get('de'), sck.get('de-1901')
# Stre-cke Stre{ck/k-k}e
#
# Versalschreibung:
#
# >>> abus = ShortEntry(u'ab<bü-ßen')
# >>> print abus.get('de'), abus.get('de-CH')
# ab<bü-ßen ab<büs-sen
# >>> print abus.get('de-1901-x-versal'), abus.get('de-CH-1901')
# ab<bü-ssen ab<büs-sen
#
# >>> print ShortEntry(u'passt').get('de-1901')
# paßt
# >>> print ShortEntry(u'passt').get('de-1901-x-versal')
# passt
# >>> rs = ShortEntry(u'-1-;-2-;Russ') # versal für Ruß
# >>> print rs.get('de-x-versal')
# Russ
# >>> rs.get('de-1901-x-versal')
# u''
#
# >>> entry = ShortEntry(u'süß=sau-er')
# >>> print entry.get('de-CH'), entry.get('de-1901-x-versal'), entry.get('de-CH-1901')
# süss=sau-er süss=sau-er süss=sau-er
#
# >>> ShortEntry(u'Pro<zess=en-.de').get('de-CH-1901')
# u'Pro<zess=en-.de'
# >>> pstr = ShortEntry(u'Pass=stra-ße')
# >>> print pstr.get('de-1996'), pstr.get('de-1901')
# Pass=stra-ße Paß=stra-ße
# >>> print pstr.get('de-x-versal'), pstr.get('de-1901-x-versal')
# Pass=stras-se Pass=stra-sse
#
# Test: Wenn keine Ersatzschreibung vorliegt, wird auch in traditioneller
# Versalschreibung s-s getrennt:
#
# >>> print ShortEntry(u'Bu-ße').get('de-1901-x-versal')
# Bu-sse
# >>> print ShortEntry(u'Bus-se').get('de-1901-x-versal')
# Bus-se
#
# Geerbt von `WordEntry.get()`_.
#
# .. _ShortEntry.complete():
#
# complete()
# ----------
#
# Eintrag vervollständigen (alle 5 Felder ausfüllen).
#
# >>> dst.complete()
# >>> print dst
# Diens-te;Dien-ste;Diens-te;Dien-ste;Dien-ste
# >>> aalbst.complete()
# >>> print aalbst
# Aal=be<stand;Aal=be<stand;Aal=be<stand;Aal=be<stand;Aal=be<stand # Test
# >>> abus.complete()
# >>> print unicode(abus)
# ab<bü-ßen;ab<bü-ßen;ab<büs-sen;ab<bü-ssen;ab<büs-sen
# >>> bss.complete()
# >>> print unicode(bss)
# Boss;Boss;Boss;Boss;Boss # engl.
# >>> frs.complete()
# >>> print unicode(frs)
# -1-;-2-;fräs-se;frä-sse;fräs-se
# >>> tpp.complete()
# >>> print tpp
# Ur<laubs=tipp;-2-;Ur<laubs=tipp;-4-;-5-
#
# >>> entry = ShortEntry(u'# toller Hecht')
# >>> entry.complete()
# >>> print unicode(entry)
# # toller Hecht
#
# ::

    def complete(self):
        for i in range(len(self), 5):
            try:
                field = self.getitem(i)
            except ValueError: # leerer Eintrag
                return
            self.append(field)


# completed()
# -----------
#
# Gib eine vervollständigte Kopie des Eintrags zurück.
#
# >>> entry = ShortEntry(u'-1-;-2-;sties-se').completed()
# >>> entry
# ShortEntry(u'-1-;-2-;sties-se;-4-;-5-')
# >>> [field for field in entry]
# [u'', u'', u'sties-se', u'', u'']
# >>> print unicode(pstr.completed())
# Pass=stra-ße;Paß=stra-ße;Pass=stras-se;Pass=stra-sse;Pass=stras-se
#
# Geerbt von `WordEntry.completed()`_.
#
#
# prune()
# -------
#
# Eintrag kürzen.
#
# Felder weglassen, wenn sich der Inhalt durch Ersatzregeln_ gewinnen läßt:
#
# >>> aalbst.prune()
# >>> print aalbst
# Aal=be<stand # Test
# >>> dst.prune()
# >>> print dst
# Diens-te
# >>> abus.prune()
# >>> print unicode(abus)
# ab<bü-ßen
# >>> bss.prune()
# >>> print unicode(bss)
# Boss;Boss # engl.
# >>> tpp.prune()
# >>> print tpp
# Ur<laubs=tipp;-2-
#
# Auch das „Auskreuzen“ wird weitergereicht:
#
# Wenn ein Wort in "traditioneller" Rechtschreibung nicht existiert, reicht
# das "Auskreuzen" von Feld 2:
#
# >>> entry = ShortEntry(u'Tipp;-2-;Tipp;-4-;-5-')
# >>> entry.prune()
# >>> print entry
# Tipp;-2-
#
# Wenn ein Wort in aktueller Rechtschreibung nicht existiert, reicht das
# "Auskreuzen" von Feld 1:
#
# >>> entry = ShortEntry(u'-1-;Rauh=nacht;-3-;Rauh=nacht')
# >>> entry.prune()
# >>> print entry
# -1-;Rauh=nacht
#
# Felder werden nicht gekürzt, wenn die Rekonstruktion einen anderen Wert
# ergäbe:
#
# >>> frs.prune()
# >>> print unicode(frs)
# -1-;-2-;fräs-se;frä-sse;fräs-se
#
# >>> entry = ShortEntry(u'-1-;Dreß;-3-;-4-;-5-')
# >>> entry.prune()
# >>> print unicode(entry)
# -1-;Dreß;-3-;-4-;-5-
#
# Mit ``drop_sz=True`` werden die drei letzten Felder (ß-Ersatzschreibung)
# stets gekürzt:
#
# * ß-Ersatzschreibung ist immer definiert, daher kann eigentlich nichts falsch
#   gemacht werden.
#
# * Die "nachlässige" Wandlung garantiert nicht die exakte Reproduktion der
#   Ausgangsliste nach einem "Rundtrip":
#
#   Mit `ShortEntry.complete()`_ werden die letzten Spalten ausgefüllt, auch
#   wenn sie im Original "ausgekreuzt" waren.
#
#   Bei Wandlung ins Langformat können zusätzliche Einträge mit
#   ß-Ersatzschreibung entstehen.
#
#   Die Auszeichnung von Mehrdeutigkeiten (z.B. „Mas-se/Ma-sse“ in
#   de-1901-x-versal) geht verloren.
#
# >>> entry.prune(drop_sz=True)
# >>> print unicode(entry)
# -1-;Dreß
# >>> entry.complete()
# >>> print unicode(entry)
# -1-;Dreß;-3-;Dress;Dress
#
# ::

    def prune(self, drop_sz=False):
        if len(self) == 1: # bereits kompakt
            return
        if drop_sz:
            while len(self) > 2:
                self.pop()
        for i in range(len(self)-1, 0, -1):
            wort = self.pop()
            rekonstruktion = self.getitem(i)
            if wort != rekonstruktion:
                # print tag, repr(self), wort, rekonstruktion
                self.append(wort)
                return
        if len(self) == 1 and not self[0]:
            self.pop()


# merge()
# -------
#
# Einträge zusammenlegen.
#
# Das als Argument übergebene WordEntry Objekt wird in dem eigenen Eintrag
# eingegliedert.
#
# Leere („ausgekreuzte“) Felder werden überschrieben:
#
# >>> entry = ShortEntry(u'be<wusst;-2-')
# >>> entry.merge(ShortEntry(u'-1-;be<wußt'))
# >>> print unicode(entry)
# be<wusst
#
# Identische Felder bleiben erhalten. Alle Felder die über Transformationen_
# rekonstruiert werden können werden entfernt:
#
# >>> entry = ShortEntry(u'Maß=nah-me # < nehmen')
# >>> entry.merge(ShortEntry(u'-1-;-2-;Mass=nah-me'))
# >>> print unicode(entry)
# Maß=nah-me # < nehmen
# >>> entry = ShortEntry(u'-1-;-2-;Mass=nah-me')
# >>> entry.merge(ShortEntry(u'Maß=nah-me # < nehmen'), merge_comments=True)
# >>> print unicode(entry)
# Maß=nah-me # < nehmen
#
# Es sei den die Option ``prune`` ist ``False``:
#
# >>> entry.merge(ShortEntry(u'Maß=nah-me'), prune=False)
# >>> print unicode(entry)
# Maß=nah-me;Maß=nah-me;Mass=nah-me;Mass=nah-me;Mass=nah-me # < nehmen
#
# Bei Konflikten wird ein AssertionError erzeugt:
#
# >>> entry = ShortEntry(u'be<wusst;-2-')
# >>> entry.merge(ShortEntry(u'-1-;-2-;ver<bor-gen'))
# Traceback (most recent call last):
#     ...
# AssertionError: Merge Error:
#  be<wusst;-2-;be<wusst;-4-;-5-
#  -1-;-2-;ver<bor-gen;-4-;-5-
#
# Geerbt von `WordEntry.merge()`_
#
#
# wordentries()
# -------------
#
# Gib eine Liste von WordEntry_ Instanzen (8-Spalten-Format_) zurück.
#
# >>> mse = ShortEntry(u'Mas-se')
# >>> mse.wordentries()
# [WordEntry(u'Masse;Mas-se')]
#
# Im Langformat gibt es für jede Schreibung einen separaten Eintrag:
#
# >>> mas = ShortEntry(u'Ma-ße')
# >>> for e in mas.wordentries():
# ...     print unicode(e)
# Maße;Ma-ße
# Masse;-2-;-3-;-4-;-5-;Ma-sse;Mas-se;Mas-se
#
# >>> entry = ShortEntry(u'Löss')
# >>> for e in entry.wordentries():
# ...     print unicode(e)
# Löss;-2-;-3-;Löss;Löss
# Löß;-2-;Löß;-4-
#
# ::

    def wordentries(self, prune=True):

        if not self:
            if self.comment: # leerer Kommentar
                return [WordEntry(u'# '+self.comment)]
            return [WordEntry(u'')]

        entries = [] # liste für WordEntry Einträge (Rückgabeobjekt)
        words = {} # dictionary für WordEntry Einträge
        # Zuordnung der Indizes: ShortEntry[s] == WordEntry[l]
        indices = (3, 2, 6, 5, 7)

        for s,l in enumerate(indices):
            word = self.getitem(s)
            if not word:
                continue # Leerfelder überspringen
            # Schlüssel:
            key = join_word(word)
            # WordEntry Instanz heraussuchen oder erzeugen:
            try:
                entry = words[key]
            except KeyError:
                entry = WordEntry(key)
                entry.comment = self.comment
                words[key] = entry
                entries.append(entry)
            # Eintrag in entry[j]:
            entry.setitem(l, word)

        # Auffüllen und Komprimieren
        for entry in entries:
            while len(entry) < 8:
                entry.append(u'')
            if prune:
                entry.prune()
        return entries


# Hilfsfunktion für Tests:
#
# >>> def print_langform(line, prune=True):
# ...   for e in ShortEntry(line).wordentries(prune):
# ...       print unicode(e)
#
# Eine Schreibung:
#
# >>> print_langform(u'ba-den')
# baden;ba-den
# >>> print_langform(u'Wes-te')
# Weste;-2-;We-ste;Wes-te
# >>> print_langform(u'Toll-patsch;-2-')
# Tollpatsch;-2-;-3-;Toll-patsch
# >>> print_langform(u'-1-;rau-he')
# rauhe;-2-;rau-he;-4-
#
# Unterschiedliche Schreibungen:
#
# >>> print_langform(u'Ab<fall=la-ger # Rechtschreibänderung')
# Abfalllager;-2-;-3-;Ab<fall=la-ger # Rechtschreibänderung
# Abfallager;-2-;Ab<fa{ll/ll=l}a-.ger;-4- # Rechtschreibänderung
#
# >>> print_langform(u'Ab<guss')
# Abguss;-2-;-3-;Ab<guss;Ab<guss
# Abguß;-2-;Ab<guß;-4-
#
# >>> print_langform(u'groß')
# groß;groß
# gross;-2-;-3-;-4-;gross
#
# >>> print_langform(u'gro-ßen')
# großen;gro-ßen
# grossen;-2-;-3-;-4-;-5-;gro-ssen;gros-sen;gros-sen
#
# >>> print_langform(u'Spaß')
# Spaß;Spaß
# Spass;-2-;-3-;-4-;Spass
# >>> print_langform(u'Spass')
# Spass;-2-;-3-;Spass;Spass
# Spaß;-2-;Spaß;-4-
# >>> print_langform(u'spa-ßen')
# spaßen;spa-ßen
# spassen;-2-;-3-;-4-;-5-;spa-ssen;spas-sen;spas-sen
#
# >>> print_langform(u'ab<bü-ßen')
# abbüßen;ab<bü-ßen
# abbüssen;-2-;-3-;-4-;-5-;ab<bü-ssen;ab<büs-sen;ab<büs-sen
#
# >>> print_langform(u'Biss')
# Biss;-2-;-3-;Biss;Biss
# Biß;-2-;Biß;-4-
# >>> print_langform(u'Boss;Boss # engl.')
# Boss;Boss # engl.
#
# >>> print_langform(u'Pass=sys-tem')
# Passsystem;-2-;-3-;Pass=sys-tem;-5-;Pass=sy-stem;Pass=sys-tem
# Paßsystem;-2-;Paß=sy-stem;-4-
#
# >>> print_langform(u'Press=saft')
# Presssaft;-2-;-3-;Press=saft;Press=saft
# Preßsaft;-2-;Preß=saft;-4-
#
# >>> print_langform(u'Pro<gramm==maß=nah-me')
# Programmmaßnahme;-2-;-3-;Pro<gramm==maß=nah-me
# Programmaßnahme;-2-;Pro<gra{mm/mm==m}aß=nah-me;-4-
# Programmmassnahme;-2-;-3-;-4-;-5-;-6-;Pro<gramm==mass=nah-me
# Programmassnahme;-2-;-3-;-4-;-5-;Pro<gra{mm/mm==m}ass=nah-me;-7-
#
# >>> print_langform(u'Pass=stra-ße')
# Passstraße;-2-;-3-;Pass=stra-ße
# Paßstraße;-2-;Paß=stra-ße;-4-
# Passstrasse;-2-;-3-;-4-;-5-;Pass=stra-sse;Pass=stras-se;Pass=stras-se
#
# >>> print_langform(u'Pro<zess=en-.de;Pro<zeß=en-de;Pro<zess=en-.de')
# Prozessende;-2-;-3-;Pro<zess=en-.de;Pro<zess=en-.de
# Prozeßende;-2-;Pro<zeß=en-de;-4-
#
# Explizit nur eine Schreibung:
#
# >>> print_langform(u'Abend=dress;Abend=dress')
# Abenddress;Abend=dress
# >>> print_langform(u'-1-;Abend=dreß')
# Abenddreß;-2-;Abend=dreß;-4-
# Abenddress;-2-;-3-;-4-;-5-;Abend=dress;-7-
#
# Nur Versalschreibung:
#
# >>> print_langform(u'-1-;-2-;Fuss;Fuss;Fuss')
# Fuss;-2-;-3-;-4-;Fuss
# >>> line = u'Fussballiga;-2-;-3-;-4-;-5-;Fuss=ba{ll/ll=l}i-.ga'
# >>> print ShortEntry(WordEntry(line), prune=False)
# -1-;-2-;-3-;Fuss=ba{ll/ll=l}i-.ga;Fuss=ba{ll/ll=l}i-.ga
# >>> print_langform(u'-1-;-2-;-3-;Fuss=ba{ll/ll=l}i-.ga;Fuss=ba{ll/ll=l}i-.ga')
# Fussballiga;-2-;-3-;-4-;-5-;Fuss=ba{ll/ll=l}i-.ga;-7-
# >>> print_langform(u'-1-;-2-;Fuss=ball==li-ga')
# Fussballliga;-2-;-3-;-4-;-5-;-6-;Fuss=ball==li-ga
#
# Nur Kommentar:
#
# >>> print_langform(u'# holla')
# # holla
#
#
# Transformationen
# ================
#
# ableitung1901()
# ---------------
#
# Ableitung von de-1901 aus de-1996 (Reversion der Reform 1996).
#
# Mit keep_key == True werden nur Änderungen vorgenommen, die die
# Schreibung des (ungetrennten) Wortes nicht verändern.
#
# >>> from wortliste import ableitung1901
#
# ::

def ableitung1901(wort, keep_key=False):
    """Reverse regular changes of the 1996 orthography reform."""


# Trennregeländerungen
# ~~~~~~~~~~~~~~~~~~~~
#
# Diese Regeln ändern nicht das Wort, nur die Trennmöglichkeiten.
#
# Alternativtrennungen
# """"""""""""""""""""
#
# (siehe `fremdwortsilben()`_, `verblasst()`_)::

    wort = fremdwortsilben(wort)
    wort = verblasst(wort)

# st-Trennung
# """""""""""
#
# K75: Trenne nie st.
#
# Ersetze 's-t' mit '-st':
#
# >>> ableitung1901(u'Diens-te')
# u'Dien-ste'
# >>> print ableitung1901(u'wuss-te', keep_key=True)
# wuss-te
#
# Aber Trennung von s-theta erlaubt (nach K74):
#
# >>> print ableitung1901(u'Äs-thet')
# Äs-thet
#
# ::

    wort = re.sub(u'(?<!s)s-t(?!h)', u'-st', wort)


# ck-Trennung
# """""""""""
#
# K76: Trenne 'ck' als 'k-k'.
#
# Ersetze '-ck' mit '{ck/k-k}':
#
# >>> ableitung1901(u'Ha-cke')
# u'Ha{ck/k-k}e'
# >>> ableitung1901(u'Acker')
# u'A{ck/k-k}er'
# >>> ableitung1901(u'Got-tes=acker')
# u'Got-tes=a{ck/k-k}er'
# >>> ableitung1901(u'Aal=beck')
# u'Aal=beck'
# >>> ableitung1901(u'be<spick-te')
# u'be<spick-te'
#
# ::

    wort = wort.replace(u'-ck', u'{ck/k-k}')
    wort = re.sub(u'(?<=[AEIOUYÄÖÜaeiouyäöü])ck(?=[aeiouyäöü])',
                  u'{ck/k-k}', wort)

#
# Keine Trennung nach nur einem Buchstaben am Wortanfang:
#
# >>> ableitung1901(u'Es-te')
# u'Este'
# >>> print ableitung1901(u'Nord=os-ten')
# Nord=osten
# >>> print ableitung1901(u'Po-ly<es-ter')
# Po-ly<ester
#
# Im Wort sind Einvokalsilben erlaubt (aber nicht immer günstig):
#
# >>> print ableitung1901(u'the-is-tisch')
# the-i-stisch
#
# ::

    wort = re.sub(u'((?<=[=<].)|(?<=^.))-', ur'', wort)

    if keep_key:
        return wort

# Rechtschreibänderungen
# ~~~~~~~~~~~~~~~~~~~~~~
#
# Diese Regeln ändern die Schreibung des ungetrennten Worts (und somit den
# Schlüssel im Langformat der Wortliste).
#
# Schluss-ss
# """"""""""
#
# K38: Kein "ss" und "sst" am Silbenende (ungetrenntes "ss" nur in Ausnahmen)
# (Andererseit ist 'ßt' und Schluss-ß auch in de-1996 möglich (langer Vokal).)
#
# Ersetze ungetrenntes 'ss' mit 'ß':
#
# >>> print ableitung1901(u'passt')
# paßt
# >>> print ableitung1901(u'Hass')
# Haß
# >>> print ableitung1901(u'Fass=brau-se')
# Faß=brau-se
# >>> print ableitung1901(u'wuss-te')
# wuß-te
#
# ß steht für inlautendes ss, wenn ein 'e' ausfällt (und der Ausfall nicht
# durch Apostroph angedeutet wird)
#
# >>> print ableitung1901(u'wäss-rig')
# wäß-rig
# >>> print ableitung1901(u'an<ge<mess-ner')
# an<ge<meß-ner
# >>> print ableitung1901(u'duss-lig')
# duß-lig
# >>> print ableitung1901(u'bissl')
# bißl
#
# Keine Wandlung zu "ß":
# getrenntes Doppel-s (s-s)
#
# >>> print ableitung1901(u'Was-ser')
# Was-ser
#
# Vokal folgt (Fremdwörter):
# >>> print ableitung1901(u'Com-tesse')
# Com-tesse
#
# Großbuchstabe folgt
#
# >>> print ableitung1901(u'WissZeitVG') # Abkürzung
# WissZeitVG
#
# Drei oder mehr 's' = Lautmalerei → erhalten:
#
# >>> print ableitung1901(u'pssst')
# pssst
#
# ::

    wort = re.sub(u'(?<=[^s])ss(?=[^aeiouyäöüA-Zs]|$)', ur'ß', wort)

# Unterdrückung der Trennstelle nach "…ß=er" und "…ß=en" nicht nötig:
#
# >>> print ableitung1901(u'hass=er<.füllt')
# haß=er<füllt
#
# ::

    wort = re.sub(ur'ß(=+)e([rn][<-]+)\.', ur'ß\1e\2', wort)

# Dreikonsonantenregel
# """"""""""""""""""""
#
# K78: Zusammensetzungen, bei denen von drei zusammenstoßenden gleichen
# Konsonanten einer entfällt (K15), schreibt man bei Silbentrennung wieder
# mit allen drei Konsonanten.
#
# Ersetze 'xx=x' xit '{xx/xx=x}' (für alle Konsonanten vor Selbstlaut)
#
# >>> print ableitung1901(u'Kipp=pflug')
# Kipp=pflug
# >>> print ableitung1901(u'Kipp=punkt')
# Ki{pp/pp=p}unkt
# >>> print ableitung1901(u'Ab<fall=la-ger')
# Ab<fa{ll/ll=l}a-.ger
# >>> print ableitung1901(u'All<lie-be')
# A{ll/ll<l}ie-be
# >>> print ableitung1901(u'hell>licht')
# he{ll/ll>l}icht
# >>> print ableitung1901(u'Pro<gramm==maß=nah-me')
# Pro<gra{mm/mm==m}aß=nah-me
#
# ::

    wort = re.sub(ur'([bfglmnprt])\1([<=>]+)\1(?=[aeiouyäöü])',
                  ur'{\1\1/\1\1\2\1}', wort)

# Unterdrücken der Trennung nach nur einem Buchstaben::

    wort = re.sub(ur'(?<=[=>].}[aeiouyäöü])([-<])\.?', ur'\1.', wort)


    return wort

# Tests:
#
# Ein-Vokal-Silben auch schon 1901 erlaubt:
#
# >>> print ableitung1901(u'ver<knäu-e-le')
# ver<knäu-e-le
#
#
# versalschreibung()
# ------------------
# Ersetze 'ß' mit 'ss', trenne je nach Sprachvarietät `lang`:
#
# >>> from wortliste import versalschreibung
# >>> print versalschreibung(u'paßt')
# passt
# >>> print versalschreibung(u'Dar-ßer')
# Dars-ser
# >>> print versalschreibung(u'bü-ßen', 'de-CH')
# büs-sen
# >>> print versalschreibung(u'bü-ßen', 'de-1996-x-versal')
# büs-sen
# >>> print versalschreibung(u'bü-ßen', 'de-CH-1901')
# büs-sen
# >>> print versalschreibung(u'äßen', 'de-CH-1901')
# äs-sen
# >>> print versalschreibung(u'auf<äßen', 'de-CH-1901')
# auf<äs-sen
# >>> print versalschreibung(u'auf<eßt', 'de-CH-1901')
# auf<esst
# >>> print versalschreibung(u'Groß=se-gel', 'de-1901-x-versal')
# Gross=se-gel
# >>> print versalschreibung(u'Groß=se-gel', 'de-CH-1901')
# Gross=se-gel
# >>> print versalschreibung(u'Paß=sy-ste-me', 'de-CH-1901')
# Pass=sy-ste-me
# >>> print versalschreibung(u'Pro<zeß=en-de', 'de-CH-1901')
# Pro<zess=en-.de
# >>> print versalschreibung(u'Pro<zess=en-.de', 'de-CH-1901')
# Pro<zess=en-.de
# >>> print versalschreibung(u'Fluß==sy-stem', 'de-CH-1901')
# Fluss==sy-stem
# >>> print versalschreibung(u'Meß==sen-der', 'de-CH-1901')
# Mess==sen-der
#
# ::

def versalschreibung(wort, lang='de'):

    if not u'ß' in wort:
        return wort

    wort = wort.replace(u'ß', u'ss')

# Trennung von Ersatz-ss in de-CH und de-1996 nach Sprechsilbenregel::

    if '1901-x-versal' not in lang:
        # wort = re.sub(u'(?<=[aeiouyäöü])-\.?ss', u's-s', wort)
        wort = re.sub(u'-\.?ss(?=[aeiouyäöü])', u's-s', wort)
        wort = re.sub(u'(?<=^[aeiouyäöü])ss(?=[aeiouyäöü])', u's-s', wort)
        wort = re.sub(u'(?<=[=<][aeiouyäöü])ss(?=[aeiouyäöü])', u's-s', wort)

# Unterdrückung irreführender Trennung::

    wort = re.sub(u'ss(=+)(en|er)([<-])\.?', ur'ss\1\2\3.', wort)

# Dreikonsonantenregel für Ersatz-ss in de-CH-1901::

    if 'CH-1901-x-dreikonsonanten' in lang:
        wort = re.sub(u'ss(=+)s(?=[aeiouyäöü])', ur'{ss/ss\1s}', wort)
        # Unterdrücken der Trennung nach nur einem Buchstaben und irreführender Trennungen
        wort = re.sub(ur'(?<=[=>]s}[aeiouyäöü])([-<])\.?', ur'\1.', wort)
        # wort = re.sub(ur'(?<===s}[aeiouyäöü])([-<])\.?', ur'\1.', wort) # Reißverschus=sy-.stem
        wort = re.sub(u'(?<=[=>]s})(en|er)([<-])\.?', ur'\1\2.', wort)

    return wort


# Kurzformat in Langformat
# ------------------------
#
# Zusätzlich benötigte Felder werden automatisch erzeugt. Ein Kurzeintrag kann
# mehrere Langeinträge ergeben:
#
# >>> from wortliste import short2long
# >>> for line in short2long([u"Diens-te", u"Ge<biss"]):
# ...     print unicode(line)
# Dienste;-2-;Dien-ste;Diens-te
# Gebiss;-2-;-3-;Ge<biss;Ge<biss
# Gebiß;-2-;Ge<biß;-4-
#
# >>> for line in short2long([u"Ge<schoss", u"Ge<schoß # österr."]):
# ...     print unicode(line)
# Geschoss;-2-;-3-;Ge<schoss;Ge<schoss
# Geschoß;Ge<schoß # österr.
#
# short2long()
# ~~~~~~~~~~~~
# ::

def short2long(lines, sort=True, prune=True):
    """Convert sequence of lines in ShortEntry format to WordEntry instances.
    """

    # Sammeln in Liste und Dictionary:
    words = {} # zum Zusammenfassen
    entries = []

    for line in lines:
        shortentry = ShortEntry(line)
        shortentry.complete()
        for entry in shortentry.wordentries(prune=False):
            key = entry.key().lower()
            try: # Eintrag mit gleichem Schlüssel vorhanden?
                altentry = words[key]
            except KeyError: # nein -> neuer Eintrag
                words[key] = entry
                entries.append(entry)
                continue
            try:
                if entry[3]: # de-1996 non-empty
                    entry.merge(altentry, prune=False, allow_alternatives=True)
                    # Alternativen Eintrag "in-place" ersetzen:
                    for i, word in enumerate(entry):
                        altentry[i] = word
                    altentry.comment = entry.comment
                else:
                    altentry.merge(entry, prune=False, allow_alternatives=True)
            except AssertionError as e:
                sys.stderr.write(unicode(e).encode('utf8')+'\n')
                entries.append(entry)
            except IndexError: # Leerer Eintrag (Kommentar)
                entries.append(entry)


    if prune:
        for entry in entries:
            entry.prune()

    if sort:
        entries.sort(key=sortkey_duden)

    return entries

# Tests:
#
# Kommentare bleiben erhalten:
#
# >>> for line in short2long([u'Aal=an-geln', u'# toller Kommentar'],
# ...                        sort=False):
# ...     print unicode(line)
# Aalangeln;Aal=an-geln
# # toller Kommentar
#
# Beim Sortieren werden Kommenare an den Beginn geschrieben.
# >>> for line in short2long([u'# erster Kommentar',
# ...                         u'Aal=an-geln',
# ...                         u'# zweiter Kommentar']):
# ...     print unicode(line)
# # erster Kommentar
# # zweiter Kommentar
# Aalangeln;Aal=an-geln
#
#
# Langformat in Kurzformat
# ------------------------
#
# Optionale Felder werden weggelassen, wenn sie mit dem automatisch erzeugten
# Inhalt übereinstimmen:
#
# >>> from wortliste import long2short
# >>> for entry in long2short([u"Dienste;-2-;Dien-ste;Diens-te"]):
# ...     print unicode(entry)
# Diens-te
#
# Zusammengehörige Einträge werden zusammengefasst:
#
# >>> for line in long2short([u"Großanlass;-2-;-3-;Groß=an<lass",
# ...                         u"Großanlaß;-2-;Groß=an<laß;-4-",
# ...                         u"Grossanlass;-2-;-3-;-4-;Gross=an<lass"]):
# ...     print unicode(line)
# Groß=an<lass
#
# Sonderfälle
# ~~~~~~~~~~~
#
# Bei einigen Wörtern ist die ß-ss-Beziehung nicht eindeutig:
#
# =======  ========  =========
# de1901   de-1996   de-CH
# =======  ========  =========
# Maße     Maße      Masse
# Masse    Masse     Masse
# Geschoß  Geschoß   Geschoss
# Geschoß  Geschoss  Geschoss
# =======  ========  =========
#
# Daher kann es vorkommen, dass ein Langform-Eintrag Beiträge von
# verschiedenen Kurzformen erhält. So erzeugen, z.B. sowohl
# „Masse“ als auch „Maße“ einen Langeintrag mit Schlüssel „Masse“:
#
# >>> for entry in short2long([u'Mas-se']): print unicode(entry)
# Masse;Mas-se
# >>> for entry in short2long([u'Ma-ße']): print unicode(entry)
# Masse;-2-;-3-;-4-;-5-;Ma-sse;Mas-se;Mas-se
# Maße;Ma-ße
#
# In der Langform werden Alternativen in ein Feld geschrieben:
#
# >>> for entry in short2long([u'Mas-se', u'Ma-ße']):
# ...     print unicode(entry)
# Masse;-2-;Mas-se;Mas-se;-5-;Ma[s-/-s]se;Mas-se;Mas-se
# Maße;Ma-ße
#
# Sind die Alternativen bereits in der Quelle, bleiben sie in der Kurzform
# erhalten:
#
# >>> ml = [u'Masse;-2-;Mas-se;Mas-se;-5-;Ma[-s/s-]se;Mas-se;Mas-se',
# ...       u'Maße;Ma-ße']
# >>> for entry in long2short(ml):
# ...     print unicode(entry)
# Mas-se;Mas-se;Mas-se;Ma[-s/s-]se
# Ma-ße;Ma-ße;Mas-se;Ma[-s/s-]se
#
# Zurück in die Langform:
#
# >>> for entry in short2long([u'Mas-se;Mas-se;Mas-se;Ma[-s/s-]se',
# ...                            u'Ma-ße;Ma-ße;-3-;Ma[-s/s-]se']):
# ...     print unicode(entry)
# Masse;-2-;Mas-se;Mas-se;-5-;Ma[-s/s-]se;Mas-se;Mas-se
# Maße;Ma-ße
#
# long2short()
# ~~~~~~~~~~~~
# ::

def long2short(lines, prune=True, drop_sz=False):
    """Convert sequence of 8-column lines to ShortEntry instances."""
    words = {}           # Einträge mit `de`
    words_x = {}         # Einträge ohne `de`
    words_merged = set() # Einträge die vollständig in andere einsortiert wurden
    entries = []         # Rückgabewert: Liste der Kurzeinträge

# Zeilen Einlesen, Wandeln und Sammeln::

    for line in lines:
        longentry = WordEntry(line)
        entry = ShortEntry(longentry, prune=False)
        key = entry.key().lower() # Schlüssel ohne Großschreibung

        if not entry: # reiner Kommentar oder leerer Eintrag
            if entry.comment:
                entries.append(entry)
            continue

        # Einträge mit leerem ersten Feld werden später einsortiert:
        if prune and not entry[0]:
            words_x[key] = entry
            continue

        # Eintrag in `dictionary` und Liste:
        words[key] = entry
        entries.append(entry)

# Straffen (Weglassen von Feldern/Einträgen wenn möglich),
# es sei denn, der Aufruf erfolgte mit `prune=False`::

    if not prune:
        return entries

    for entry in entries:

        # Auffüllen:
        for i in range(1, len(entry)):
            if not entry[i]:  # Feld ausgekreuzt
                key_i = join_word(entry.getitem(i, substitute=True)).lower()
                # print i, key_i
                try:
                    co_entry = words_x[key_i]
                    entry.merge(co_entry, prune=False, start=1)
                    words_merged.add(key_i)
                    # del words_x[key_i]
                except (KeyError, AssertionError):
                    try:
                        co_entry = words[key_i]
                        entry.merge(co_entry, prune=False, start=1)
                        words_merged.add(key_i)
                    except (KeyError, AssertionError):
                        pass

# Anhängen aller Einträge mit leerem `de`-Feld, die nicht in
# einen  zugehörigen Eintrag einsortiert wurden an die Liste::

    for key, entry in words_x.iteritems():
        # print key, unicode(entry)
        if key in words_merged:
            continue
        # ggf. ergänzen:
        if len(entry) > 2 and not entry[3]:  # de-1901-x-versal
            key = join_word(entry.getitem(3, substitute=True)).lower()
            try:
                co_entry = words_x[key]
                entry.merge(co_entry, prune=False, start=3)
                words_merged.add(key)
            except (KeyError, AssertionError):
                try:
                    co_entry = words[key]
                    entry.merge(co_entry, prune=False, start=3)
                    # print key, unicode(co_entry)
                except (KeyError, AssertionError):
                    pass

        entries.append(entry)

    for entry in entries:
        entry.prune(drop_sz)

    return entries

# Tests:
#
# Separate Einträge ß-Schreibungen zusammenfassen:
#
# Ein von 2 ß wird zu ss in de-1996:
#
# >>> for entry in long2short([
# ...       u'Passstrasse;-2-;-3-;-4-;-5-;Pass=stra-sse;Pass=stras-se;Pass=stras-se',
# ...       u'Passstraße;-2-;-3-;Pass=stra-ße',
# ...       u'Paßstraße;-2-;Paß=stra-ße;-4-']):
# ...     print unicode(entry)
# Pass=stra-ße
#
# ß in de-1996:
#
# >>> for line in long2short([
# ...       u"Grossserie;-2-;-3-;-4-;-5-;Gross=se-rie;Gross=se-rie",
# ...       u"Großserie;Groß=se-rie"]):
# ...     print unicode(line)
# Groß=se-rie
#
# kein ß in de-1996:
#
# >>> for line in long2short([
# ...       u"Basssaite;-2-;-3-;Bass=sai-te;-5-;Bass=sai-te;Bass=sai-te",
# ...       u"Baßsaite;-2-;Baß=sai-te;-4-"]):
# ...     print unicode(line)
# Bass=sai-te
#
# Zusätzliche Variante (Fremdwort vs. Lehnwort) in de-1901:
#
# >>> for entry in short2long([u'Boss;Boss # en.']): print unicode(entry)
# Boss;Boss # en.
# >>> for entry in long2short([u'Boss;Boss # en.']): print unicode(entry)
# Boss;Boss # en.
# >>> for entry in long2short([u'Boss;Boss # en.', u'Boß;-2-;Boß;-3- # < en.']):
# ...     print unicode(entry)
# Boss;Boss # en.
# -1-;Boß # < en.
#
# Alternativschreibung in de-1996 (Geschoß, Löß):
#
# >>> for entry in long2short([u'Geschoss;-2-;-3-;Ge<schoss;Ge<schoss',
# ...                          u'Geschoß;Ge<schoß # österr. auch de-1996']):
# ...     print unicode(entry)
# Ge<schoss
# Ge<schoß # österr. auch de-1996
#
# Eigennamen auf -ss:
#
# >>> for entry in long2short([u'Vossstrasse;-2-;-3-;-4-;-5-;Voss=stra-sse;Voss=stras-se;Voss=stras-se',
# ...                          u'Vossstraße;Voss=stra-ße',
# ...                          u'Voßstraße;Voß=stra-ße']):
# ...     print unicode(entry)
# Voss=stra-ße;Voss=stra-ße
# Voß=stra-ße
#
# Kommentare:
#
# >>> long2short(['# toller Kommentar'], prune=False)
# [ShortEntry(u'# toller Kommentar')]
# >>> long2short(['# toller Kommentar'], prune=True)
# [ShortEntry(u'# toller Kommentar')]
#
#
# Trennfilter
# ===========
#
# Funktionen, die einen Trennstil (oder einen Aspekt eines Trennstils)
# implementieren (siehe auch dokumentation/Trennstile.txt).
#
# fremdwortsilben()
# -----------------
#
# Entferne Alternativtrennungen bei einfachen und suffigierten Fremdwörtern:
#
# Regelwerk (1996) § 112:
#    In Fremdwörtern können die Verbindungen aus Buchstaben für einen
#    Konsonanten + l, n oder r entweder entsprechend § 110 getrennt werden,
#    oder sie kommen ungetrennt auf die neue Zeile.
#
# >>> from wortliste import fremdwortsilben
#
# >>> fremdwoerter = (u'no-b-le Zy-k-lus Ma-g-net Fe-b-ru-ar '
# ...                 u'Hy-d-rant Ar-th-ri-tis ger<i-a-t-ri-sche')
# >>> for wort in fremdwoerter.split():
# ...     print wort, '->', fremdwortsilben(wort)
# no-b-le -> no-ble
# Zy-k-lus -> Zy-klus
# Ma-g-net -> Ma-gnet
# Fe-b-ru-ar -> Fe-bru-ar
# Hy-d-rant -> Hy-drant
# Ar-th-ri-tis -> Ar-thri-tis
# ger<i-a-t-ri-sche -> ger<i-a-tri-sche
#
# >>> for wort in fremdwoerter.split():
# ...     print wort, '->', fremdwortsilben(wort, 'modern')
# no-b-le -> nob-le
# Zy-k-lus -> Zyk-lus
# Ma-g-net -> Mag-net
# Fe-b-ru-ar -> Feb-ru-ar
# Hy-d-rant -> Hyd-rant
# Ar-th-ri-tis -> Arth-ri-tis
# ger<i-a-t-ri-sche -> ger<i-at-ri-sche
#
# ::

def fremdwortsilben(wort, style='etymologisch'):
    """Select in-word hyphenation of foreign words."""
    if style == "modern": # Sprechsilbenregel
        return re.sub(u'-([bcdfgkptv]|th)-(?=[lrn])', u'\\1-', wort) # §112
    else: # morphematisch
        return re.sub(u'-([bcdfgkptv]|th)-(?=[lrn])', u'-\\1', wort) # K86, K87
    # Versuch: auch Alternativtrennung nach führendem Vokal:
    # Ap-ri-kose -> Apri-kose aber auch Ad-ler -> Adler (!)
    # return re.sub(u'(-|^[AEIOUÄÖÜaeiouäöü])([bcdfgkptv]|th|st)-(?=[lrn])',
    #               u'\\1\\2', wort)

# Tests:
#
# K86 Untrennbar sind in Fremdwörtern die Verbindungen von Verschluß- und
# Reibelauten mit l und r, ...
#
# >>> fremdwoerter = (u'Pu-b-li-kum flexi-b-ler Zy-k-lone Qua-d-rat '
# ...                 u'Spek-t-rum manö-v-rieren')
# >>> for wort in fremdwoerter.split():
# ...     print wort, '->', fremdwortsilben(wort)
# Pu-b-li-kum -> Pu-bli-kum
# flexi-b-ler -> flexi-bler
# Zy-k-lone -> Zy-klone
# Qua-d-rat -> Qua-drat
# Spek-t-rum -> Spek-trum
# manö-v-rieren -> manö-vrieren
#
# die Lautfolge st+r bleibt ungetrennt, wenn keine Wortfuge vorliegt.
#
# >>> fremdwoerter = u'Di-st-rikt Magi-st-rat laku-st-risch  ab-st-rakt'
# >>> for wort in fremdwoerter.split():
# ...     print wort, '->', fremdwortsilben(wort)
# Di-st-rikt -> Di-strikt
# Magi-st-rat -> Magi-strat
# laku-st-risch -> laku-strisch
# ab-st-rakt -> ab-strakt
#
# K 87 Untrennbar ist die Konsonantenverbindung "gn".
#
# >>> fremdwoerter = u'Ma-g-net Pro-g-nose Si-g-net'
# >>> for wort in fremdwoerter.split():
# ...     print wort, '->', fremdwortsilben(wort)
# Ma-g-net -> Ma-gnet
# Pro-g-nose -> Pro-gnose
# Si-g-net -> Si-gnet
#
# Keine Übergeneralisierung:
#
# >>> woerter = u'Seg-ler bast-le Ad-ler'
# >>> for wort in woerter.split():
# ...     print wort, '->', fremdwortsilben(wort)
# Seg-ler -> Seg-ler
# bast-le -> bast-le
# Ad-ler -> Ad-ler
#
# wegen Übergeneralisierung nicht möglich:
# Ap-ri-kose -> Apri-kose
# ig-no-rie-ren -> igno-rie-ren
#
#
# verblasst()
# --------------
#
# Entferne Alternativtrennungen nach §113 (verblasste Etymologie).
#
# Regelwerk (1996) §113:
#   Wörter, die sprachhistorisch oder von der Herkunftssprache her gesehen
#   Zusammensetzungen oder Präfigierungen sind, aber nicht mehr als solche
#   empfunden oder erkannt werden, kann man entweder nach § 108 oder nach §
#   109 bis § 112 trennen.
#
# >>> from wortliste import verblasst
# >>> blasse = (u'hi-n<auf he-r<an da-r<um Chry-s<an-the-me Hek-t<ar '
# ...           u'He-li-ko<p-ter in-te-r>es-sant Li-n<oleum Pä-d<a-go-gik')
# >>> for wort in blasse.split():
# ...     print wort, '->', verblasst(wort)
# hi-n<auf -> hin<auf
# he-r<an -> her<an
# da-r<um -> dar<um
# Chry-s<an-the-me -> Chrys<an-the-me
# Hek-t<ar -> Hekt<ar
# He-li-ko<p-ter -> He-li-ko<pter
# in-te-r>es-sant -> in-ter>es-sant
# Li-n<oleum -> Lin<oleum
# Pä-d<a-go-gik -> Päd<ago-gik
#
# >>> for wort in blasse.split():
# ...     print wort, '->', verblasst(wort, 'modern')
# hi-n<auf -> hi-nauf
# he-r<an -> he-ran
# da-r<um -> da-rum
# Chry-s<an-the-me -> Chry-san-the-me
# Hek-t<ar -> Hek-tar
# He-li-ko<p-ter -> He-li-kop-ter
# in-te-r>es-sant -> in-te-res-sant
# Li-n<oleum -> Li-noleum
# Pä-d<a-go-gik -> Pä-da-go-gik
#
# Ersetze, wenn zwischen Haupttrennstelle und Nebentrennstelle nur ein
# Buchstabe liegt.
# (Die Haupttrennstelle kann vor oder nach der Nebentrennstelle liegen.)
# ::

def verblasst(wort, style='morphematisch'):
    """Select hyphenation of foreign words with obscure etymology."""
    if style == "modern": # Sprechsilbenregel
        wort = re.sub(u'[<>=]+[.]*(.[-.]+)', u'\\1', wort)
        wort = re.sub(u'([-.]+.)[<>=]+[.]*', u'\\1', wort)
    else: # morphematisch
        wort = re.sub(u'([<>=]+[.]*.)[-.]+', u'\\1', wort)
        wort = re.sub(u'[-.]+(.[<>=]+)', u'\\1', wort)
    return wort



# Tests:
#
# K44 „ſ“ (langes s) steht in Fremdwörtern...
#
# >>> blasse = (u'tran<s-pirieren tran<s-zendent ab<s-tinent '
# ...           u'Ab<s-zess Pro-s<odie')
# >>> for wort in blasse.split():
# ...     print wort, '->', verblasst(wort)
# tran<s-pirieren -> tran<spirieren
# tran<s-zendent -> tran<szendent
# ab<s-tinent -> ab<stinent
# Ab<s-zess -> Ab<szess
# Pro-s<odie -> Pros<odie
#
# Trennstellen können als ungünstig markiert sein:
#
# >>> blasse = (u'Bür-ger=in<.i-ti-a-ti-ve Pä-..d<e-..rast')
# >>> for wort in blasse.split():
# ...     print wort, '->', verblasst(wort)
# Bür-ger=in<.i-ti-a-ti-ve -> Bür-ger=in<.iti-a-ti-ve
# Pä-..d<e-..rast -> Päd<erast
# >>> for wort in blasse.split():
# ...     print wort, '->', verblasst(wort, 'modern')
# Bür-ger=in<.i-ti-a-ti-ve -> Bür-ger=ini-ti-a-ti-ve
# Pä-..d<e-..rast -> Pä-..de-..rast
#
#
# scoretext()
# ------------
#
# Füge Trennmöglichkeiten am Wortanfang und -ende zu, die nach K79 (bzw. §107
# E2 des Regelwerkes) verboten sind aber in Notentexten gebraucht werden.
#
# >>> from wortliste import scoretext
# >>> scoretext(u'Abend')
# u'A.bend'
# >>> scoretext(u'Ra-dio')
# u'Ra-di.o'
#
# Das gleiche gilt für Trennmöglichkeiten am Anfang/Ende von Teilwörtern:
#
# >>> scoretext(u'Eis=ano-ma-lie')
# u'Eis=a.no-ma-lie'
# >>> scoretext(u'Ra-dio<phon')
# u'Ra-di.o<phon'
#
# Ausnahmen:
#
# >>> scoretext(u'Ai-chin-ger'), scoretext(u'Ai-da')
# (u'Ai-chin-ger', u'A.i-da')
# >>> scoretext(u'Ma-rie'), scoretext(u'Li-nie')
# (u'Ma-rie', u'Li-ni.e')
# >>> scoretext(u'Ta-too'), scoretext(u'Zoo<lo-gie')
# (u'Ta-too', u'Zo.o<lo-gie')
# >>> scoretext(u'A-pnoe'), scoretext(u'O-boe')
# (u'A-pnoe', u'O-bo.e')
# >>> scoretext(u'Plaque'), scoretext(u'treue')
# (u'Plaque', u'treu.e')
# >>> scoretext(u'Fon-due=pfan-ne'), scoretext(u'Aue')
# (u'Fon-due=pfan-ne', u'Au.e')
# >>> scoretext(u'Ge-nie'), scoretext(u'Iphi-ge-nie')
# (u'Ge-nie', u'I.phi-ge-nie')
# >>> scoretext(u'Ago-nie'), scoretext(u'Be-go-nie')
# (u'A.go-nie', u'Be-go-ni.e')
# >>> scoretext(u'Kom-pa-nie'), scoretext(u'Kas-ta-nie'), scoretext(u'Ge-ra-nie')
# (u'Kom-pa-nie', u'Kas-ta-ni.e', u'Ge-ra-ni.e')
#
# ungelöst: Knie  / Kni.e # pl.
# ::

def scoretext(word):
    """Mark up leading one-letter syllables."""
    # Führender Vokal, gefolgt von Silbenanfang
    # (optionaler Konsonant (auch ch/ck/ph/rh/sch/sh/th) + Vokal)
    for match in re.finditer(u'(^|[<=])([aeiouäöü])((.|ch|ck|ph|sch|th)?[aeiouäöü])',
                             word, flags=re.IGNORECASE):
        # print match.groups()
        # Ausnahmen: Doppellaute, Diphtonge (außer A-i-da), Umlaute
        if (re.search(u'(aa|ae|ai|au|äu|ei|eu|oe|oo|ou|ue)',
                      match.group(0), flags=re.IGNORECASE)
            and word != u'Ai-da' or word == u'io-ta' ):
            continue
        word = ''.join((word[:match.start()], match.expand(u'\\1\\2.\\3'),
                        scoretext(word[match.end():])))
        break
    # zwei Vokale am Wortende
    for match in re.finditer(u'([aeiouäöü])([aeiouäöü])([<>=]|$)', word):
        # if re.search(u'(oo)', match.group(0)):
        # if 'ie' in match.group(0) and re.search(u'([a]-nie)', word, flags=re.IGNORECASE):
            # sys.stderr.write(word+' '+match.group(0)+'\n')
        # Ausnahmen: Doppellaute, Diphtonge, Umlaute (außer "Oboe")
        if (re.search(u'(aa|ae|ai|au|äu|ee|ei|eu|oe|oi|ou|ui)', match.group(0))
            and not word[:match.end()].endswith(u'waii') # ! Hawaii
            and not word[:match.end()].endswith(u'boe')): # ! Oboe
            continue
        # Ausnahmen mit Ausnahmen:
        # …oo außer zoo<, ...
        if 'oo' in match.group(0) and match.group(0) != 'oo<':
            continue
        # …ie außer "-(l)inie", Iphigenie, Kastanie, Geranie, Begonie
        if ('ie' in match.group(0)
            and not word[:match.end()].endswith(u'i-nie') # Linie,
            and not word[:match.end()].endswith(u'ta-nie') # Kastanie,
            and not word[:match.end()].endswith(u'ra-nie') # Geranie,
            and not word[:match.end()].endswith(u'e-go-nie') # Begonie != Agonie
            and not word == u'Iphi-ge-nie'):
            continue
        # …ue (Plaque, Re-vue, vogue) außer "-tue, -aue, ... -äue"
        if 'ue' in match.group(0) and re.search(u'[^aeät]ue([<>=]|$)',
                            word[:match.end()], flags=re.IGNORECASE):
            continue

        word = ''.join((word[:match.start()], match.expand(u'\\1.\\2\\3'),
                        scoretext(word[match.end():])))
        break
    return word


# keine_einzelvokale()
# --------------------
#
# Traditionell enthalten die TeX-Trennmuster keine Trennstellen deren Abstand
# zur Nachbartrennstelle einen Buchstaben beträgt. Dies ist eine *ästhetische*
# Entscheidung um „Flatterbuchstaben“ zu vermeiden
#
# Bei einvokalischen Silben im Wortinneren, nimm die zweite:
#
# >>> from wortliste import keine_einzelvokale
# >>> einzelne = (u'The-a-ter me-ri-di-.o-nal')
# >>> for wort in einzelne.split():
# ...     print wort, '->', keine_einzelvokale(wort)
# The-a-ter -> Thea-ter
# me-ri-di-.o-nal -> me-ri-dio-nal
#
# Allerdings nicht, wenn die erste Trennstelle unterdrückt ist:
#
# >>> einzelne = (u'La-sal-le-a-.ner Athe-i-.sten')
# >>> for wort in einzelne.split():
# ...     print wort, '->', keine_einzelvokale(wort)
# La-sal-le-a-.ner -> La-sal-le-a-.ner
# Athe-i-.sten -> Athe-i-.sten
#
# ::

def keine_einzelvokale(wort):
    """Drop hyphenation marker after single vowels."""
    return re.sub(u'-[.]*([aeiouyäöü])(?=-[^.])', u'\\1', wort)


# unguenstig()
# ------------
#
# Entferne die explizit als ungünstig gekennzeichneten Trennstellen:
#
# >>> from wortliste import unguenstig
# >>> unguenstig(u'Text=il<..lu-stra-ti-.on')
# u'Text=illu-stra-tion'
# >>> unguenstig(u'Text=il<..lu-stra-ti-.on', level=2)
# u'Text=illu-stra-ti-on'

# ::

def unguenstig(wort, level=1):
    """Drop bad hyphenations."""
    marker = r'\.' * level
    wort = re.sub(u'[-=<>]+%s+'%marker, u'', wort)
    return wort.replace(u'.', u'')

# Hilfsfunktionen
# ===============
#
# join_word()
# -----------
#
# Trennzeichen entfernen::

def join_word(wort, assert_complete=False):

# Einfache Trennzeichen:
#
# ==  ================================================================
# \=  Trennstelle an Wortfugen (Wort=fu-ge)
# \<  Trennstelle nach Präfix  (Vor<sil-be)
# \>  Trennstelle vor Suffix   (Freund>schaf-ten)
# \-  Nebentrennstelle         (ge-hen)
# \.  unerwünschte/ungünstige Trennstelle (Ge<schoss=en<.er-gie)
# ==  ================================================================
#
# ::

    for marker in u'=<>-.':
        wort = wort.replace(marker, u'')

# Spezielle Trennungen für die traditionelle Rechtschreibung
# (siehe ../../dokumente/README.wortliste)::

    if '{' in wort or '}' in wort:
        wort = wort.replace(u'{ck/kk}',  u'ck')
        wort = wort.replace(u'{ck/k',  u'k')
        wort = wort.replace(u'k}',     u'k')
        # Konsonanthäufungen an Wortfuge: '{xx/xxx}' -> 'xx':
        wort = re.sub(ur'\{(.)\1/\1\1\1\}', ur'\1\1', wort)
        # schon getrennt: ('{xx/xx' -> 'xx' und 'x}' -> 'x'):
        wort = re.sub(ur'\{(.)\1/\1\1$', ur'\1\1', wort)
        wort = re.sub(ur'^(.)\}', ur'\1', wort)

# Trennstellen in doppeldeutigen Wörtern::

    if '[' in wort or ']' in wort:
        wort = re.sub(ur'\[(.*)/\1\]', ur'\1', wort)
        # schon getrennt:
        wort = re.sub(ur'\[([^/\[]+)$', ur'\1', wort)
        wort = re.sub(ur'^([^/\]]+)\]', ur'\1', wort)

# Test auf verbliebene komplexe Trennstellen::

    if assert_complete:
        for spez in u'[{/}]':
            if  spez in wort:
                raise AssertionError('Spezialtrennung %s, %s' %
                                     (wort.encode('utf8'), wort.encode('utf8')))

    return wort

# zerlege()
# ---------
#
# Zerlege ein Wort mit Trennzeichen in eine Liste von Silben und eine Liste
# von Trennzeichen)
#
# >>> from wortliste import zerlege
#
# >>> zerlege(u'Haupt=stel-le')
# ([u'Haupt', u'stel', u'le'], [u'=', u'-'])
# >>> zerlege(u'Ge<samt=be<triebs=rats==chef')
# ([u'Ge', u'samt', u'be', u'triebs', u'rats', u'chef'], [u'<', u'=', u'<', u'=', u'=='])
# >>> zerlege(u'an<stands>los')
# ([u'an', u'stands', u'los'], [u'<', u'>'])
# >>> zerlege(u'An<al.pha-bet')
# ([u'An', u'al', u'pha', u'bet'], [u'<', u'.', u'-'])
#
# ::

def zerlege(wort):
    silben = re.split(u'[-·._<>=]+', wort)
    trennzeichen = re.split(u'[^-·._|<>=]+', wort)
    return silben, [tz for tz in trennzeichen if tz]

# alternatives()
# --------------
#
# Gib einen String mit Trennmarkierung für abweichende Trennungen in
# mehrdeutigen Wörtern zurück:
#
# >>> from wortliste import alternatives
# >>> alternatives(u'Mas-se', u'Ma-sse')
# u'Ma[s-/-s]se'
# >>> alternatives(u'Ma-sse', u'Mas-se')
# u'Ma[-s/s-]se'
#
# ::

def alternatives(wort1, wort2):
    # convert to lists
    wort1 = [c for c in wort1]
    wort2 = [c for c in wort2]
    pre = []
    post = []
    for c1, c2 in zip(wort1, wort2):
        if c1 != c2:
            break
        pre += c1
    for c1, c2 in zip(wort1.__reversed__(), wort2.__reversed__()):
        if c1 != c2:
            break
        post += c1
    post.reverse()
    return u''.join(pre + [u'['] + wort1[len(pre):-len(post)] + [u'/']
                  + wort2[len(pre):-len(post)] + [u']'] + post)

# TransferError
# -------------
#
# Fehler beim Übertragen von Trennstellen mit uebertrage()_::

class TransferError(ValueError):
    def __init__(self, wort1, wort2):
        msg = u'Inkompatibel: %s %s' % (wort1, wort2)
        ValueError.__init__(self, msg.encode('utf8'))

    def __unicode__(self):
        return str(self).decode('utf8')


# uebertrage()
# ------------
#
# Übertrage die Trennzeichen von `wort1` auf `wort2`:
#
# >>> from wortliste import uebertrage, TransferError
#
# >>> uebertrage(u'Haupt=stel-le', u'Haupt·stel·le')
# u'Haupt=stel-le'
#
# Auch teilweise Übertragung, von "kategorisiert" nach "unkategorisiert":
#
# >>> print uebertrage(u'Haupt=stel-le', u'Haupt=stel·le')
# Haupt=stel-le
#
# >>> print uebertrage(u'Haupt·stel-le', u'Haupt=stel·le')
# Haupt=stel-le
#
# >>> print uebertrage(u'Aus<stel-ler', u'Aus-stel-ler')
# Aus<stel-ler
#
# >>> print uebertrage(u'Freund>schaf·ten', u'Freund-schaf-ten')
# Freund>schaf-ten
#
# Übertragung doppelter Marker:
#
# >>> print uebertrage(u'ver<<aus<ga-be', u'ver<aus<ga-be')
# ver<<aus<ga-be
#
# >>> print uebertrage(u'freund>lich>>keit', u'freund>lich>keit')
# freund>lich>>keit
#
# >>> print uebertrage(u'Amts==haupt=stel-le', u'Amts=haupt=stel-le')
# Amts==haupt=stel-le
#
# Kein Überschreiben doppelter Marker:
# >>> print uebertrage(u'ver<aus<ga-be', u'ver<<aus<ga-be')
# ver<<aus<ga-be
#
# >>> print uebertrage(u'Amts=haupt=stel-le', u'Amts==haupt=stel·le')
# Amts==haupt=stel-le
#
# Erhalt des Markers für ungünstige Stellen:
# >>> print uebertrage(u'An·al.pha·bet', u'An<al.pha-bet')
# An<al.pha-bet
#
# Keine Übertragung, wenn die Zahl oder Position der Trennstellen
# unterschiedlich ist oder bei unterschiedlichen Wörtern:
#
# >>> try:
# ...     uebertrage(u'Ha-upt=stel-le', u'Haupt=stel·le')
# ...     uebertrage(u'Haupt=ste-lle', u'Haupt=stel·le')
# ...     uebertrage(u'Waupt=stel-le', u'Haupt=stel·le')
# ... except TransferError:
# ...     pass
#
# Übertragung auch bei unterschiedlicher Schreibung oder Position der
# Trennstellen mit `strict=False` (für Abgleich zwischen Sprachvarianten):
#
# >>> uebertrage(u'er-ster', u'ers·ter', strict=False)
# u'ers-ter'
# >>> uebertrage(u'Fluß=bett', u'Fluss·bett', strict=False)
# u'Fluss=bett'
# >>> uebertrage(u'ab>bei-ßen', u'ab>beis·sen', strict=False)
# u'ab>beis-sen'
# >>> print uebertrage(u'Aus<tausch=dien-stes', u'Aus-tausch=diens-tes', False)
# Aus<tausch=diens-tes
#
# Auch mit `strict=False` muß die Zahl der Trennstellen übereinstimmen
# (Ausnahmen siehe unten):
#
# >>> try:
# ...     uebertrage(u'Ha-upt=ste-lle', u'Haupt=stel·le', strict=False)
# ... except TransferError:
# ...     pass
#
# Akzeptiere unterschiedliche Anzahl von Trennungen bei st und ck nach
# Selbstlaut:
#
# >>> uebertrage(u'acht=ecki-ge', u'acht·e{ck/k·k}i·ge', strict=False)
# u'acht=e{ck/k-k}i-ge'
# >>> uebertrage(u'As-to-ria', u'Asto·ria', strict=False)
# u'Asto-ria'
# >>> uebertrage(u'Asto-ria', u'As·to·ria', strict=False)
# u'As-to-ria'
# >>> uebertrage(u'So-fa=ecke', u'So·fa=e{ck/k-k}e', strict=False)
# u'So-fa=e{ck/k-k}e'
# >>> uebertrage(u'Drei=ecks=ecke', u'Drei=ecks==e{ck/k-k}e', strict=False)
# u'Drei=ecks==e{ck/k-k}e'
#
# Mit ``upgrade=False`` werden nur unspezifische Trennstellen überschrieben:
#
# >>> print uebertrage(u'an=stel-le', u'an<stel·le', upgrade=False)
# an<stel-le
#
# >>> print uebertrage(u'Aus<stel-ler', u'Aus-stel-ler', upgrade=False)
# Aus-stel-ler
#
# >>> print uebertrage(u'Aus-stel-ler', u'Aus<stel-ler', upgrade=False)
# Aus<stel-ler
#
# >>> print uebertrage(u'vor<an<<stel-le', u'vor-an<stel·le', upgrade=False)
# vor-an<stel-le
#
# ::

selbstlaute = u'aeiouäöüAEIOUÄÖÜ'

def uebertrage(wort1, wort2, strict=True, upgrade=True):

    silben1, trennzeichen1 = zerlege(wort1)
    silben2, trennzeichen2 = zerlege(wort2)
    # Prüfe strikte Übereinstimmung:
    if silben1 != silben2 and strict:
        if u'<' in trennzeichen1 or u'·' in trennzeichen2:
            raise TransferError(wort1, wort2)
        else:
            return wort2
    # Prüfe ungefähre Übereinstimmung:
    if len(trennzeichen1) != len(trennzeichen2):
        # Selbstlaut + st oder ck?
        for s in selbstlaute:
            if (wort2.find(s+u'{ck/k·k}') != -1 or
                wort2.find(s+u'{ck/k-k}') != -1):
                wort1 = re.sub(u'%sck([%s])'%(s,selbstlaute),
                               ur'%s-ck\1'%s, wort1)
                silben1, trennzeichen1 = zerlege(wort1)
            if wort2.find(s+u's·t') != -1:
                wort1 = wort1.replace(s+u'st', s+u's-t')
                silben1, trennzeichen1 = zerlege(wort1)
            elif wort1.find(s+u's-t') != -1:
                wort1 = wort1.replace(s+u's-t', s+u'st')
                silben1, trennzeichen1 = zerlege(wort1)
                # print u'retry:', silben1, trennzeichen1
        # immer noch ungleiche Zahl an Trennstellen?
        if len(trennzeichen1) != len(trennzeichen2):
            raise TransferError(wort1, wort2)

    # Baue wort3 aus silben2 und spezifischeren Trennzeichen:
    wort3 = silben2.pop(0)
    for t1,t2 in zip(trennzeichen1, trennzeichen2):
        if ((t2 == u'·' and t1 != u'.') # unspezifisch
            or upgrade and
            ((t2 in (u'-', u'<') and t1 in (u'<', u'<<', u'<=')) # Praefixe
             or (t2 in (u'-', u'>') and t1 in (u'>', u'>>', u'=>')) # Suffixe
             or (t2 in (u'-', u'=') and t1 in (u'=', u'==', u'===')) # W-fugen
            )
           ):
            wort3 += t1
        elif t2 == u'.' and t1 not in u'·.':
            wort3 += t1 + t2
        else:
            wort3 += t2
        wort3 += silben2.pop(0)
    return wort3


# Übertrag kategorisierter Trennstellen zwischen den Feldern aller Einträge
# in `wortliste`::

def sprachabgleich(entry, vorbildentry=None):

    if len(entry) <= 2:
        return # allgemeine Schreibung

    mit_affix = None       # < oder >
    kategorisiert = None   # kein ·
    unkategorisiert = None # mindestens ein ·
    gewichtet = None       # == oder <= oder =>
    for field in entry[1:]:
        if not field: # -2-, -3-, ...
            continue
        if u'{' in field and u'[' in field: # Bi-ber==be[t=t/{tt/tt=t}]uch
            continue # zu komplex
        if u'·' in field:
            unkategorisiert = field
        elif u'<' in field or u'>' in field:
            mit_affix = field
        else:
            kategorisiert = field
        if u'==' in field or u'<=' in field or u'=>' in field:
            gewichtet = field
    if vorbildentry:
        for field in vorbildentry[1:]:
            if not field: # -2-, -3-, ...
                continue
            if u'{' in field and u'[' in field: # Bi-ber==be[t=t/{tt/tt=t}]uch
                continue # zu komplex
            if not mit_affix and u'<' in field or u'>' in field :
                mit_affix = field
            elif not kategorisiert and unkategorisiert and u'·' not in field:
                kategorisiert = field
            if not gewichtet and u'==' in field or u'<=' in field or u'=>' in field:
                gewichtet = field
        # print 've:', mit_affix, kategorisiert, unkategorisiert
    if mit_affix and (kategorisiert or unkategorisiert or gewichtet):
        for i in range(1,len(entry)):
            if not entry[i]: # -2-, -3-, ...
                continue
            if u'<' not in entry[i] or u'·' in entry[i]:
                try:
                    entry[i] = uebertrage(mit_affix, entry[i], strict=False)
                except TransferError, e:
                    if not '/' in entry[i]:
                        print u'Sprachabgleich:', unicode(e)
        # print mit_affix+u':', unicode(entry)
    elif kategorisiert and unkategorisiert:
        for i in range(1,len(entry)):
            if u'·' in entry[i]:
                try:
                    entry[i] = uebertrage(kategorisiert, entry[i], strict=False)
                except TransferError, e:
                    print u'Sprachabgleich:', unicode(e)
        # print kategorisiert, unicode(entry)
    elif gewichtet:
        for i in range(1,len(entry)):
            if u'=' in entry[i] and not (
                                u'{' in entry[i] and u'[' in entry[i]):
                try:
                    entry[i] = uebertrage(gewichtet, entry[i], strict=False)
                except TransferError, e:
                    print u'Sprachabgleich:', unicode(e)



# Großschreibung in Kleinschreibung wandeln und umgekehrt
#
# Diese Version funktioniert auch für Wörter mit Trennzeichen (während
# str.title() nach jedem Trennzeichen wieder groß anfängt)
#
# >>> from wortliste import toggle_case
# >>> toggle_case(u'Ha-se')
# u'ha-se'
# >>> toggle_case(u'arm')
# u'Arm'
# >>> toggle_case(u'frei=bier')
# u'Frei=bier'
# >>> toggle_case(u'L}a-ger')
# u'l}a-ger'
#
# Keine Änderung bei Wörtern mit Großbuchstaben im Inneren:
#
# >>> toggle_case(u'USA')
# u'USA'
# >>> toggle_case(u'iRFD')
# u'iRFD'
#
# >>> toggle_case(u'gri[f-f/{ff/ff')
# u'Gri[f-f/{ff/ff'
# >>> toggle_case(u'Gri[f-f/{ff/ff')
# u'gri[f-f/{ff/ff'
#
# ::

def toggle_case(wort):
    try:
        key = join_word(wort, assert_complete=True)
    except AssertionError:
        key = wort[0]
    if key.istitle():
        return wort.lower()
    elif key.islower():
        return wort[0].upper() + wort[1:]
    else:
        return wort

# Sortierschlüssel
# ================
#
# Duden-Sortierung für die Wortliste
#
# >>> from wortliste import sortkey_duden
# >>> sortkey_duden([u"Abflußröhren"])
# u'abflussrohren a*bflu*szroehren'
# >>> sortkey_duden([u"Abflußrohren"])
# u'abflussrohren a*bflu*szro*hren'
# >>> sortkey_duden([u"Abflussrohren"])
# u'abflussrohren'
#
# >>> s = sorted([[u"Abflußröhren"], [u"Abflußrohren"], [u"Abflussrohren"]],
# ...            key=sortkey_duden)
# >>> print ', '.join(e[0] for e in s)
# Abflussrohren, Abflußrohren, Abflußröhren
#
# Umschreibung
#
# Ligaturen auflösen und andere "normalisierunde" Ersetzungen für den
# (Haupt-)Sortierschlüssel (Akzente werden über ``unicodedata.normalize``
# entfernt)::

umschrift_skey = {
                  ord(u'æ'): u'ae',
                  ord(u'œ'): u'oe',
                  ord(u'ſ'): u's',
                 }

# "Zweitschlüssel" zur Unterscheidung von Umlauten/SZ und Basisbuchstaben::

umschrift_subkey = {
                    ord(u'a'): u'a*',
                    ord(u'å'): u'aa',
                    ord(u'ä'): u'ae',
                    ord(u'o'): u'o*',
                    ord(u'ö'): u'oe',
                    ord(u'ø'): u'oe',
                    ord(u'u'): u'u*',
                    ord(u'ü'): u'ue',
                    ord(u'ß'): u'sz',
                   }


# sortkey_duden()
# ---------------
#
# Schlüssel für die alphabetische Sortierung gemäß Duden-Regeln.
#
# Argument ist ein Eintrag im WordEntry oder ShortEntry Format oder
# ein (Unicode) String:
#
# >>> print sortkey_duden(weste) # WordEntry
# weste
# >>> print sortkey_duden(dst) # ShortEntry
# dienste
#
# >>> print sortkey_duden(u'Stra-ße')
# strasse stra*sze
# >>> print sortkey_duden([u'Büh-ne'])
# buhne buehne
# >>> print sortkey_duden(u'Weiß=flog;Weiß=flog;-3-;-4-;-5-')
# weissflog weiszflo*g
# >>> print sortkey_duden(u'-1-;Meß=sen-der;-3-;-4-;-5-')
# messsender meszsender
# >>> print sortkey_duden(u'As-sen # (geogr. und Eigen-) Name\n')
# assen
# >>> print sortkey_duden(u'aßen;aßen;-3-;-4-;-5-\n')
# assen a*szen
# >>> print sortkey_duden(u'äßen\n')
# assen aeszen
#
# ::

def sortkey_duden(entry):

# ggf. ungetrenntes Wort extrahieren oder generieren::

    if isinstance(entry, list):
        try:
            key = entry.key()
        except AttributeError:
            key = entry[0]
            if len(entry) == 1:  # ein Muster pro Zeile, siehe z.B. pre-1901
                key = join_word(key)
    else:
        match = re.search(u'^[-0-9;]*([^;\s]+)', entry) # erstes volles Feld
        if match:
            key = match.group(1)
        else:
            key = u''
        key = join_word(key)
        key = re.sub(u'[0-9;]', ur'', key)

# Großschreibung ignorieren:
#
# Der Duden sortiert Wörter, die sich nur in der Großschreibung unterscheiden
# "klein vor groß" (ASCII sortiert "groß vor klein"). In der
# `Trennmuster-Wortliste` kommen Wörter nur mit der häufiger anzutreffenden
# Großschreibung vor, denn der TeX-Trennalgorithmus ignoriert Großschreibung.
# ::

    key = key.lower()

# Ersetzungen:
#
# ß -> ss ::

    skey = key.replace(u'ß', u'ss')

# Restliche Akzente weglassen: Wandeln in Darstellung von Buchstaben mit
# Akzent als "Grundzeichen + kombinierender Akzent". Anschließend alle
# nicht-ASCII-Zeichen ignorieren::

    skey = skey.translate(umschrift_skey)
    skey = unicodedata.normalize('NFKD', skey)
    skey = unicode(skey.encode('ascii', 'ignore'))

# "Zweitschlüssel" für das eindeutige Einsortieren von Wörtern mit
# gleichem Schlüssel (Masse/Maße, waren/wären, ...):
#
# * "*" nach aou für die Unterscheidung Grund-/Umlaut
# * ß->sz
#
# ::

    if key != skey:
        subkey = key.translate(umschrift_subkey)
        skey = u'%s %s' % (skey,subkey)

# Gib den Sortierschlüssel zurück::

    return skey



# udiff()
# -------
#
# Vergleiche zwei Sequenzen von `WordEntries` (genauer: alle Objekte, die
# sich sinnvoll zu Unicode wandeln lassen).
#
# Beispiel:
#
# >>> from wortliste import udiff
# >>> print udiff([abbeissen, aalbestand], [abbeissen,dresz], 'alt', 'neu')
# --- alt
# +++ neu
# @@ -1,2 +1,2 @@
#  abbeissen;-2-;-3-;-4-;-5-;test;ab<beis-sen;ab<beis-sen
# -Aalbestand;Aal=be<stand # Test
# +Dreß;-2-;Dreß;-4-
# <BLANKLINE>
# >>> udiff([abbeissen, aalbestand], [abbeissen, aalbestand], 'alt', 'neu')
# u''
#
# ::

def udiff(a, b, fromfile='', tofile='',
          fromfiledate='', tofiledate='', n=1, encoding='utf8'):

    a = [unicode(entry).rstrip().encode(encoding) for entry in a]
    b = [unicode(entry).rstrip().encode(encoding) for entry in b]

    diff = '\n'.join(difflib.unified_diff(a, b, fromfile, tofile,
                        fromfiledate, tofiledate, n, lineterm=''))
    if diff:
        diff += '\n'
    return diff.decode(encoding)


# Sprachtags
# ==========
#
# Normalisierung und Expansion von Sprachtags nach [BCP47]_
#
# >>> from wortliste import normalize_language_tag
# >>> normalize_language_tag('de_AT-1901')
# ['de-AT-1901', 'de-AT', 'de-1901', 'de']
#
# >>> normalize_language_tag('de')      # Deutsch, allgemeingültig
# ['de']
# >>> normalize_language_tag('de_1901') # traditionell (Reform 1901)
# ['de-1901', 'de']
# >>> normalize_language_tag('de_1996') # reformiert (Reform 1996)
# ['de-1996', 'de']
# >>> normalize_language_tag('de_CH')   # ohne ß (Schweiz oder versal)
# ['de-CH', 'de']
# >>> normalize_language_tag('de-x-versal') # versal
# ['de-x-versal', 'de']
# >>> normalize_language_tag('de-1901-x-versal') # versal
# ['de-1901-x-versal', 'de-1901', 'de-x-versal', 'de']
# >>> normalize_language_tag('de_CH-1996') # Schweiz traditionell (süssauer)
# ['de-CH-1996', 'de-CH', 'de-1996', 'de']
#
# 'de':               1, # Deutsch, allgemeingültig
# 'de-1901':          2, # "traditionell" (nach Rechtschreibreform 1901)
# 'de-1996':          3, # reformierte Reformschreibung (1996)
# 'de-x-versal':      4, # ohne ß (Schweiz oder versal) allgemein
# # 'de-CH':          4, # Alias
# 'de-1901-x-versal': 5, # ohne ß (Schweiz oder versal) "traditionell"
# 'de-1996-x-versal': 6, # ohne ß (Schweiz oder versal) "reformiert"
# # 'de-CH-1996':     6, # Alias
# 'de-CH-1901':       7, # ohne ß (Schweiz) "traditionell" ("süssauer")
#
#
# ::

def normalize_language_tag(tag):
    """Return a list of normalized combinations for a `BCP 47` language tag.
    """
    # normalize:
    tag = tag.replace('_','-')
    # split (except singletons, which mark the following tag as non-standard):
    tag = re.sub(r'-([a-zA-Z0-9])-', r'-\1_', tag)
    taglist = []
    subtags = [subtag.replace('_', '-') for subtag in tag.split('-')]
    base_tag = [subtags.pop(0)]
    # find all combinations of subtags
    for n in range(len(subtags), 0, -1):
        # for tags in unique_combinations(subtags, n):
        for tags in itertools.combinations(subtags, n):
            taglist.append('-'.join(base_tag+list(tags)))
    taglist += base_tag
    return taglist



# Tests
# =====
#
# Teste Übereinstimmung des ungetrennten Wortes in Feld 1 mit den
# Trennmustern nach Entfernen der Trennmarker. Schreibe Inkonsistenzen auf die
# Standardausgabe.
#
# Das Argument ist ein Iterator über die Einträge (Klasse `WordEntry`). ::

def test_keys(wortliste):
    print u"Teste Schlüssel-Trennmuster-Übereinstimmung:"
    is_OK = True
    for entry in wortliste:
        if isinstance(entry, ShortEntry):
            print u"Wortliste im Kurzformat: überspringe Schlüssel-Test."
            return
            # Test der Übereinstimmung ungetrenntes/getrenntes Wort
        # für alle Felder:
        key = entry.key()
        for wort in entry[1:]:
            if not wort: # leere Felder
                continue
            if key != join_word(wort):
                is_OK = False
                print u"\nkey '%s' != join_word('%s')" % (key, wort),
                if key.lower() == join_word(wort).lower():
                    print(u"  Abgleich der Großschreibung mit"
                          u"`prepare-patch.py grossabgleich`."),
    if is_OK:
        print u"OK"


# Finde Doppeleinträge (teste, ob jeder Schlüssel nur einmal vorkommt).
# Schreibe Inkonsistenzen auf die Standardausgabe.
#
# Das Argument ist ein Iterator über die Einträge (Klasse `WordEntry`). ::

def test_uniqueness(wortliste):

    doppelte = 0
    words = {}
    for entry in wortliste:
        key = entry.key()
        if key in words:
            doppelte += 1
            print "da ", unicode(words[key])
            print "neu", unicode(entry)
        words[key] = entry
    print u"%d Doppeleinträge." % doppelte

# Teste die Wandlung einer Zeile im "wortliste"-Format in eine
# ``WordEntry``-Instanz und zurück::

def test_str_entry_str_conversion(wordfile):
    OK = 0
    for line in file(wordfile.name):
        line = line.rstrip().decode(wordfile.encoding)
        entry = WordEntry(line)
        if line == unicode(entry):
            OK +=1
        else:
            print u'-', line,
            print u'+', unicode(entry)

    print OK, u"Einträge rekonstruiert"


# Teste Vervollständigung und Zusammenfassung von Einträgen::

def test_completion_pruning(entries):
    reko = []
    for entry in entries:
        new = copy.copy(entry)
        new.complete()
        new.prune()
        reko.append(new)
    patch = udiff(entries, reko, 'wortliste', 'neu')
    if patch:
        print patch
    else:
        print u"alle Einträge rekonstruiert"



# Aufruf von der Kommandozeile
# ============================
#
# ::

if __name__ == '__main__':
    import sys

    # sys.stdout mit UTF8 encoding (wie in Python 3)
    sys.stdout = codecs.getwriter('UTF-8')(sys.stdout)
    # sys.stderr = codecs.getwriter('UTF-8')(sys.stderr)

    print u"Test der Werkzeuge und inneren Konsistenz der Wortliste"

# Ein WordFile Dateiobjekt::

    try:
        wordfile = WordFile(sys.argv[1], format='auto')
    except IndexError:
        wordfile = WordFile('../../../wortliste')
        # wordfile = WordFile('../../../wlst', format='auto') # wortliste im Kurzformat
        # wordfile = WordFile('neu.todo')
        # wordfile = WordFile('neu-kurz.todo', format='f5')
        # wordfile = WordFile('korrektur.todo', format='auto')

# Format bestimmen::

    print "Datei: '%s'" % wordfile.name, u"Format:", wordfile.format

# Liste der Datenfelder (die Klasseninstanz als Argument für `list` liefert
# den Iterator über die Felder, `list` macht daraus eine Liste)::

    wordlist = list(wordfile)
    print len(wordlist), u"Zeilen"

# Ein Wörterbuch (dict Instanz)::

    wordfile.seek(0)            # Pointer zurücksetzen
    words = wordfile.asdict()
    print len(words), u"Wörterbucheinträge"

# Test auf Doppeleinträge::

    if len(words) != len(wordlist):
        test_uniqueness(wordlist)


# Teste Schlüssel-Trennmuster-Übereinstimmung::

    if isinstance(wordlist[0], WordEntry):
        test_keys(wordlist)

# Teste Eintrags-Konsistenz im Kurzformat::

    if isinstance(wordlist[0], ShortEntry):
        doppelte = 0
        langs = ("de", "de-1901", "de-CH", "de-1901-x-versal", "de-CH-1901")
        for lang in langs:
            words[lang] = {}

        for entry in wordlist:
            entry.complete()
            for lang in langs:
                word = entry.get(lang)
                key = join_word(word)
                if word and (key in words[lang]):
                    oldword = words[lang][key].get(lang)
                    if oldword and (word != oldword):
                        doppelte += 1
                        print "%-16s" % lang, oldword, '!=', word
                        print " "*18, unicode(words[lang][key].pruned())
                        print " "*18, unicode(entry.pruned())
                words[lang][key] = entry
        print u"%d Doppeleinträge." % doppelte


# Teste Komplettieren/Zusammenfassen der Einträge::

    # test_completion_pruning(wordlist)

# Sprachauswahl::

    # Sprachtags:
    #
    # sprache = 'de-1901' # traditionell
    sprache = 'de-1996' # Reformschreibung
    # sprache = 'de-x-versal'      # ohne ß (Schweiz oder versal) allgemein
    # sprache = 'de-1901-x-versal' # ohne ß (Schweiz oder versal) "traditionell"
    # sprache = 'de-1996-x-versal' # ohne ß (Schweiz oder versal) "reformiert"
    # sprache = 'de-CH-1901'       # ohne ß (Schweiz) "traditionell" ("süssauer")
    #
    # worte = [entry.get(sprache) for entry in wordlist]
    # worte = [wort for wort in worte if wort]
    # print len(worte), u"Einträge für Sprachvariante", sprache

# Zeilenrekonstruktion::

    # test_str_entry_str_conversion(wordfile)


# Quellen
# =======
#
# .. [BCP47] A. Phillips und M. Davis, (Editoren.),
#    `Tags for Identifying Languages`, http://www.rfc-editor.org/rfc/bcp/bcp47.txt
#
# .. _aktuelle Rechtschreibung:
#
# .. [Rechtschreibregeln] Rat für deutsche Rechtschreibung,
#    `Deutsche Rechtschreibung – Regeln und Wörterverzeichnis`,
#    http://www.rechtschreibrat.com/regeln-und-woerterverzeichnis/
#
# .. _traditionelle Rechtschreibung:
#
# .. [Duden1991] Wissenschaftlicher Rat der Dudenredaktion (Editoren),
#    `Duden: Rechtschreibung der deutschen Sprache`,
#    Dudenverlag Mannheim, 1991.
#
# .. _Wortliste der deutschsprachigen Trennmustermannschaft:
#    ../../../dokumente/README.wortliste
#
# .. _wortliste: ../../../wortliste