Suche eine Art "sticky" ansi sequence...

[mutetella]

Hallo,

um Suchtreffer bei der Ausgabe hervorzuheben, gehe ich so vor:

Code: Alles auswählen

def ansi_wrap(text, ansi):
    return '{0}{1}{2}'.format(ansi[0], text, ansi[1])

def highlight_ansi_wrap(text, highlights, highlight_ansi):
    if not highlights or not (highlight_ansi[0] and highlight_ansi[1]):
        return text
    for highlight in highlights:
        text = text.replace(highlight, ansi_wrap(highlight, highlight_ansi))
    return text

Code: Alles auswählen

>>> highlight_ansi_wrap('any text to highlight', ('text', 'light'), ('**ON**', '**OFF**'))
'any **ON**text**OFF** to high**ON**light**OFF**'

Jetzt stehe ich vor dem Problem, dass `text` bei Platzmangel auch mal gekürzt wird. Wenn ich also `highlight_ansi_wrap` mit bereits gekürztem `text` aufrufe, werden eventuelle `highlights` nicht mehr gefunden. Füge ich aber die ANSI Sequenzen zuvor ein, werden mir diese, falls eine Kürzung stattfindet, abgeschnitten.

Irgendwie müsste ich also beim Kürzen von `text` auch `highlights` insofern berücksichtigen, dass diese auch im gekürzten `text` (dann natürlich gekürzt) gefunden werden.

Dazu fällt mir nix gescheites ein...

mutetella

[snafu]

Nur zum Verständnis: Du möchtest also das oben hervorgehobene "light" von "highlight" auch dann hervorheben, wenn aufgrund einer Kürzung des gesamten Textes hinten etwas abgeschnitten wurde, also dass der Text jetzt z.B. nur noch auf "li" statt auf "light" enden würde? Und die Funktion soll dann "magisch" wissen, dass mit dem "li" im gekürzten Text eigentlich das "light" aus den übergebenen Funktionsargumenten gemeint ist?

[mutetella]

@snafu: Genau das meine ich. Wobei ich keine Magie suche, sondern eine Möglichkeit, einen String, der ANSI Sequenzen enthält, zu kürzen, ohne dass dabei die Sequenzen beschädigt werden oder aber die Sequenzen bei komplettem Wegfall des umschlossenen Textes ebenfalls entfernt werden. Aus highlight soll im Falle einer Kürzung highli werden.

Inzwischen könnte ich mir folgendes vorstellen: 'highlight' mit hervorgehobenem 'light' bedeutet, dass [4:9] von ANSI umgeben ist. Bleibt nach einer Kürzung etwas zwischen [4:9] übrig, wird dies wiederum innerhalb ANSI ausgegeben. Oder so... hab' das noch nicht konkret versucht.

mutetella

[snafu]

Ich habe die Idee mal in Code umgesetzt:

Code: Alles auswählen

class Highlighter(object):
    def __init__(self, text, on_mark='**ON**', off_mark='**OFF**'):
        self.text = text
        self.marked_positions = set()
        self.on_mark = on_mark
        self.off_mark = off_mark

    def highlight(self, term):
        term_width = len(term)
        current_pos = 0
        while True:
            term_startpos = self.text.find(term, current_pos)
            if term_startpos < 0:
                break
            current_pos = term_startpos + term_width
            self.marked_positions.add((term_startpos, current_pos))
            
    def to_string(self, max_len=None):
        if max_len is None:
            max_len = len(self.text)
        if max_len < 0:
            raise ValueError('max_len must be >= 0')
        return ''.join(self._get_fragments(max_len))

    def _get_fragments(self, max_len):
        text = self.text[:max_len]
        current_pos = 0
        for pos_on, pos_off in sorted(self.marked_positions):
            if pos_on >= max_len:
                break
            yield text[current_pos:pos_on]
            yield self.on_mark
            yield text[pos_on:pos_off]
            yield self.off_mark
            current_pos = pos_off
        yield text[current_pos:]

Man übergibt hier den "Rohtext" an den Highlighter und kann mittels einer Schleife für alle hervorzuhebenden Textstellen die `.highlight()`-Methode aufrufen. Die Ausgabe mitsamt Markierungen geschieht mittels `.to_string()`. Möchte man diese Ausgabe kürzen, dann gibt man `.to_string()` einfach die Anzahl der zulässigen Zeichen mit.

Ich denke, das funktioniert jetzt in etwa so, wie du es dir vorgestellt hast. Vielleicht bekommt man den Code noch etwas eleganter hin. Robust genug scheint er jedenfalls zu sein. Zumindest haben ein paar manuelle Tests immer zum erwarteten Ergebnis geführt.

[mutetella]

Wow!!! Das ist ja mal echt 'ne schöne Überraschung!!

Schade nur, dass mein Teleportationsskript noch nicht wirklich funktioniert, sonst würd' ich Dir jetzt einen Pack meiner selbstgebackenen Lebkuchen rüberschicken...

Danke!

mutetella

[mutetella]

Ich hab' noch die Möglichkeit eingebaut, mehrere Textteile zu umschließen, da es ja durchaus sein kann, dass sich ein hervorgehobener Textteil innerhalb eines anderen hervorgehobenem Textes befindet:

Code: Alles auswählen

class WrappedText(object):
    def __init__(self, text, left='', right=''):
        self.text = text
        self.markers = [(0, left, len(text), right)]

    def add(self, term, left, right):
        begin = self.text.find(term)
        end = begin + len(term)
        self.markers.append((begin, left, end, right))

    def to_string(self, length=None):
        length = length or len(self.text)
        return ''.join(self._get_fragments(length))

    def _sorted_markers(self, length):
        def _markers():
            order = 0
            for (begin_left, marker_left,
                 begin_right, marker_right) in sorted(self.markers):
                if begin_left < length:
                    yield (begin_left, order, marker_left)
                    yield (begin_right, order + 1, marker_right)
                    order += 2
        return [(m[0], m[2]) for m in sorted(_markers())]

    def _get_fragments(self, length):
        text = self.text[:length]
        begin = None
        for markers_pos, marker in self._sorted_markers(length):
            yield text[begin:markers_pos]
            yield marker
            begin = markers_pos

Code: Alles auswählen

In [270]: w = WrappedText('Ein Text mit eckigen, geschweiften und runden Klammern')

In [271]: w.add('eckigen, geschweiften und runden', '(', ')')

In [272]: w.add('geschweiften', '{', '}')

In [273]: w.add('eckigen', '[', ']')

In [274]: w.to_string()
Out[274]: 'Ein Text mit ([eckigen], {geschweiften} und runden) Klammern'

In [275]: w.to_string(18)
Out[275]: 'Ein Text mit ([eckig])'

In [276]: w.to_string(28)
Out[276]: 'Ein Text mit ([eckigen], {geschw})'

In [277]: w.to_string(42)
Out[277]: 'Ein Text mit ([eckigen], {geschweiften} und run)'

Wer Fehler findet, darf sie nicht behalten...

mutetella

[snafu]

Ist es gewollt, dass immer nur die erste Fundstelle markiert wird?

Code: Alles auswählen

>>> w = WrappedText('bla, bla, bla')
>>> w.add('bla', '(', ')')
>>> w.to_string()
'(bla), bla, bla'

[BlackJack]

Ich hätte da wahrscheinlich eine verschachtelte Datenstruktur draus gemacht. Also einen Baum aus Knoten die einen Textwert und einen Prä- und Suffix haben (die auch leer sein dürfen) und einer Sequenz von Kindern die wieder genau aus den selben Knoten bestehen.

Was mir bei Deiner Lösung nicht gefällt ist der Name `add()`. Der hat mich total verwirrt als ich das Beispiel gesehen hatte, weil ich erwartet hatte das damit Text und Prä-/Suffix hinzugefügt werden und nicht das im Text etwas gesucht und dann ausgezeichnet wird. Die API erscheint mir so auch nicht besonders praxistauglich, denn man möchte vielleicht auch Texte auszeichnen über deren kompletten Inhalt man nicht die volle Kontrolle hat, so das dort auch etwas vorkommen kann was `add()` sucht und dann wird ein falscher Teil ausgezeichnet. Als API stelle ich mir für so etwas eher verschachtelte Funktionsaufrufe vor:

Code: Alles auswählen

text = Text('Text der ', green('grün'), ' und ', bold('fett'), ' oder ', underline(italic('unterstrichen ', bold('und')), 'kursiv'), ' ist.')

So etwas kann man auch einfach aus XML oder BBCode erstellen, oder reStructuredText oder Markdown.

Code: Alles auswählen

Text der <green>grün</green> und <b>fett</b> oder <u><i>unterstrichen <b>und</b> kursiv</i></u> ist.

[mutetella]

@snafu: Nein , ich war so mit `_get_fragments` beschäftigt , dass mir das dann überhaupt nicht mehr aufgefallen ist...

@BlackJack: Mein erster Impuls war tatsächlich, snafu's `Highlighter` "schachteltauglich" zu machen, aber allein das Nachdenken darüber hat mich total überfordert ! Ich werd's nochmals angehen...

mutetella

[snafu]

@snafu: Nein , ich war so mit `_get_fragments` beschäftigt , dass mir das dann überhaupt nicht mehr aufgefallen ist...

Dann schau dir als Vorlage mal die `while True:`-Schleife aus meinem Beispiel genauer an.

Wie gesagt: Vielleicht geht's sogar noch etwas hübscher als in meiner Version.

@BlackJack: Mein erster Impuls war tatsächlich, snafu's `Highlighter` "schachteltauglich" zu machen, aber allein das Nachdenken darüber hat mich total überfordert ! Ich werd's nochmals angehen...

Das Überführen in eine Baumstruktur ist definitv ordentlicher, aber IMHO auch deutlich aufwändiger. Zudem muss ja anschließend noch geguckt werden, dass die Sache mit gekürzten Texten klarkommt. Da hat man dann jede Menge Code geschrieben für einen Effekt, den man - zumindest in Fällen ohne Verschachtelung - auch mit deutlich weniger Aufwand haben könnte. Du musst halt schauen, ob du Verschachtelung erlauben willst, oder nicht.

Ich für meinen Teil finde es oftmals frustrierend, wenn ich mir super-viel Funktionalität vorstelle und dann die Komplexität realisiere, die dahinter stecken würde. Da ist es meist motivierender, erstmal eine etwas abgespecktere Variante mit gewissen Einschränkungen zu implementieren, die dann aber genau das tut, was man von ihr erwartet. Erweiterungen (mitunter auch durch einen kompletten Neuentwurf) kann man später immer noch schreiben...

[mutetella]

@snafu: Als ich mir das gerade nochmals überlegt habe, bin ich auch zu dem Schluss gekommen, dass die jetzige Lösung wahrscheinlich sinniger ist.

@BlackJack: Ich habe eine Suchfunktion (die Du ja inzwischen kennst... ), an die ich Begriffe sende und den durchsuchten Text samt gefundenen Begriffen zurück erhalte, z. B.

Code: Alles auswählen

('Ich suche nach diesem Wort!', ('suche', 'diesem'))

Die gefunden Wörter sollen nun innerhalb des Textes ausgezeichnet werden. Muss dieser Text nochmals gekürzt werden, sollen die Auszeichnungen nicht verloren gehen. Würdest Du das trotzdem über eine Schachtellösung machen?

mutetella

[BlackJack]

@snafu: Ob das tatsächlich deutlich aufwändiger ist bezweifle ich mal. Es ist „regelmässiger” Code wegen der sehr regelmässigen Datenstruktur. Das kürzen sollte auch kein grosses Problem sein. Das ist soweit ich das sehe nur eine kleine Modifikation zum Rendern des gesamten Textes. Einfach zu jedem öffnenden ”Tag” das schliessende auf einen Stapel werfen, und wenn die maximale Textlänge erreicht ist, hängt man alle noch auf dem Stapel befindlichen schliessenden ”Tags” an das Ergebnis an und ist fertig.

[jerch]

Ich finde die API auch nicht besonders praxistauglich, das 'blah' Beispiel von snafu zeigt noch ein anderes Problem des Suchen&Dekorierens auf:

Was, wenn im Text die Stelle mehrfach vorkommt, man aber nur eine bestimmte davon dekorieren will? Dann müsste man Positionsangaben und Wissen um den Inhalt bis zum Renderer zusätzlich mitschleppen. inplace, wie BlackJack es vorschlägt, ist diese Information impliziert.

[snafu]

Auch mir ist inzwischen klar geworden, dass es ganz offensichtlich um mehr gut, als nur um "**ON**" und "**OFF**". Wie so oft bei Abstrahierungen für Fragestellungen entspricht die Abstraktion also nicht wirklich der tatsächlichen Anforderung. Wenn es wirklich darum geht, etwas wie Fettdruck, Unterstreichungen, etc für Terminalausgaben zu bekommen, dann sollte man definitiv mit einem vernünftigen Parser arbeiten. Soweit ich weiß, gibt es auf PyPi mindestens ein Paket, das genau solche Aufgaben (also speziell für's Terminal) für einen übernimmt. Den Namen müsste ich aber bei Interesse erstmal raussuchen...

[snafu]

Man könnte ja zweierlei vorgehen:

Einerseits ein Drittmodul zum Verarbeiten des Markups verwenden. Da könnte man dann auch durch explizite Angaben via Tags z.B. Überschriften (oder was auch immer) fett hervorheben, Unterstreichungen, usw machen.

Und andererseits kann ja zumindest die Suchfunktionalität der hier geposteten Klasse übernommen werden. Die `.get_text()`-Methode würde dann aufgrund der gespeicherten Positionsangaben für die Suchergebnisse dynamisch das nötige Markup erzeugen (hier wird ja vermutlich nur *eine* Tag-Art ohne weitere Verschachtelung benötigt). Dabei werden wieder die Fundstellen aus dem Originaltext für das Setzen der Tags im gekürzten Text verwendet. Nur das eigentliche Rendern geschieht dann halt mit dem Drittmodul.

[mutetella]

Mein Vorgehen (bisher) ist folgendes: Wenn ich die Spalte mit den Termintiteln erstelle, erhalte ich z. B. den Titeltext 'Zahnarzt Wurzelbehandlung' mit der Information, dass nach dem Begriff 'Wurzel' gesucht wurde. Die Schritte dabei:

• Den Text für die Titelspalte auszeichnen -> '\033[32mZahnarzt Wurzelbehandlung\033[39m'
• Den gefundenen Begriff als solchen auszeichnen -> '\033[32mZahnarzt \033[;4mWurzel\033[;24mbehandlung\033[39m'
• Den Text auf den verfügbaren Raum kürzen -> '\033[32mZahnarzt \033[;4mWurz\033[;24m\033[39m'

[/list]

Müsste ich diesen Text erstellen, bräuchte ich dafür ja die "Einzelteile" ('Zahnarzt ', 'Wurzel', 'behandlung'), würde diese auszeichnen und wieder zusammensetzen. Wo dabei das Kürzen stattfindet, weiß ich jetzt noch gar nicht. Also eine API in diesem Sinne...

Als API stelle ich mir für so etwas eher verschachtelte Funktionsaufrufe vor:

Code: Alles auswählen

text = Text('Text der ', green('grün'), ' und ', bold('fett'), ' oder ', underline(italic('unterstrichen ', bold('und')), 'kursiv'), ' ist.')

... ist doch für mein Vorhaben eher umständlicher, oder hab' ich einfach nur eine falsche Vorstellung davon?

Was, wenn im Text die Stelle mehrfach vorkommt, man aber nur eine bestimmte davon dekorieren will?

Dann hätte ich ein Problem... Kommt aber eigentlich nicht vor, da ich nur Textteile auszeichnen möchte, die bei einer vorangegangenen Suche gefunden wurden. Und was gefunden wurde, soll auch ausgezeichnet werden.

Nur, dass ihr mich richtig versteht: Ich versuche nicht krampfhaft, euch zu widersprechen. Ich hab allerdings die Vorteile gegenüber meiner Methode noch nicht wirklich verstanden.

mutetella

[BlackJack]

@mutetella: Das Vorgehen wäre dann:

* Text für Titel: 'Zahnarzt Wurzelbehandlung'
* Mit einer Funktion das Suchwort auszeichnen. → x = text('Zahnarzt ', bold('Wurzel'), 'behandlung')
* Gesamttext auszeichnen: x = bright(x)
* Gekürzten Text rendern: x.render(13) → '\033[32mZahnarzt \033[;4mWurz\033[;24m\033[39m'

Im zweiten Schritt steht rechts vom ``=`` nicht das was man tatsächlich schreibt sondern ein Ausdruck der das gleiche Ergebnis liefert wie die Funktion die 'Wurzel' sucht und auszeichnet. Ob die Funktionsnamen `bold()` und `bright()` zu den ANSI-Sequenzen passen, die Du angegeben hast, habe ich jetzt auch nicht geprüft. Wahrscheinlich nicht. Oh, und bei der 13 habe ich mich hoffentlich auch nicht verzählt.

[jerch]

@mutetella:
Ich werd das Gefühl nicht los, dass Du Dich mit der Sache etwas verrennst und etwas zu lösen versuchst, was so nicht lösbar ist und eigentlich ein Neuüberdenken benötigt. Hierzu mal ein paar Überlegungen zur Verkürzung. Das ist imho non trivial, damit da noch etwas sematisch Sinnvolles raus kommt. Beispiel:

Eintrag A:
"muss noch den Garten winterfest machen, Geranien ausgraben, Wurzeln lüften"
Eintrag B:
"Zahnarzt, Wurzelbehandlung"

Wie gehst Du mit dem Suchwort "Wurzel" um für die Einträge, wenn nur, sagen wir, für 10 Zeichen Platz ist?

Möglichkeit 1 wäre, einfach vom Anfang her zu kürzen:
A: "muss noch "
B: "Zahnarzt, "

Möglichkeit 2 wäre, im Umfeld des Suchwortes zu kürzen:
A: ", Wurzeln "
B: ", Wurzelbe"

Beides produziert mehr oder weniger Unsinn. An dieser Stelle musst Du Dich fragen, wie sinnvoll diese Funktion überhaupt ist oder mit welchen Einschränkungen/Erweiterungen dies tatsächlich funktionieren kann. Hierzu fallen mir spontan 3 Möglichkeiten ein:

1. Festlegung auf Kürzung vom Anfang her mit der Maßgabe, dass wichtige Schlüsselwörter vorne stehen müssen
Damit funktionieren alle Einträge ala B gut, A produziert Unsinn.

2. Einführung von expliziten Schlüsselwörtern
Mit der Einführung von expliziten Schlüsselwörtern, z.B. über Hashtags (Twitter machts vor) könnte man das Problem insofern lösen, dass man mit der Verkürzung auf diese Wörter reduziert, Beispiel:
"muss noch den #Garten winterfest machen, #Geranien ausgraben, #Wurzeln lüften"
render(10) --> "Garten ..."
Hier ist dann die Frage zu klären, wie genau mit den Hastags zu verfahren ist.

3. Vergiss den Versuch, das sinnvoll abbilden zu können und erweitere lieber die UI. Z.B. mit Hover-Funktion, welche in einem "Terminal-Popup" oder über kurze Userinteraktionswege in der Lage ist, den kompletten Eintrag anzuzeigen.

Ich würde wahrscheinlich zu 2. oder 3. tendieren und eine der Möglichkeiten weiter ausbauen. Vllt. sind die Überlegungen als Denkanstösse für Dich brauchbar.

[mutetella]

@jerch:
Ich denke, man muss zwischen der notwendigen Kürzung von Text und dem optionalen Gimmick einer Hervorhebung von Suchbegriffen unterscheiden. Denkst Du nicht, dass man das ganz pragmatisch sehen kann/muss:

• Ist eine Hervorhebung von Suchergebnissen erwünscht, werden Suchergebnisse hervorgehoben.
• Wird eine Kürzung von Text vorgenommen, sieht man weniger vom Text.

Möglichkeit 1 wäre, einfach vom Anfang her zu kürzen:
A: "muss noch "
B: "Zahnarzt, "

Möglichkeit 2 wäre, im Umfeld des Suchwortes zu kürzen:
A: ", Wurzeln "
B: ", Wurzelbe"

Beides produziert mehr oder weniger Unsinn.

Möglichkeit 1: So kenne ich das von den allermeisten Programmen. Macht ja auch in den allermeisten Situationen Sinn.
Möglichkeit 2: Manche commandline Tools arbeiten so, halte ich aber nur für sinnvoll, wenn eine solche Ausgabe im Kontext zur Herkunft, z. B. einer Datei, steht.

Mit der Einführung von expliziten Schlüsselwörtern, z.B. über Hashtags [...] Hier ist dann die Frage zu klären, wie genau mit den Hastags zu verfahren ist.

Ist ja letztlich durch das Anlegen von Kategorien abgedeckt. Wenn ich also meinen Zahnarzt suche, kann ich ja alle Termine der Kategorie 'Arzttermine' anzeigen. #Hashtags, die innerhalb des eigentlichen #Textes gesetzt werden, halte ich neben der #Einführung von #RedBull für eine der #schlimmsten #Sünden neuerer #Zeit.

... und erweitere lieber die UI. Z.B. mit Hover-Funktion, ...

Eine solche Funktion benötigt es in jedem Fall, da ja, wie schon gesagt, Text meistens auf irgendeine Art gekürzt werden muss. Ohne dieser Möglichkeit würden viele Daten nie wieder zur Anzeige gelangen.

mutetella


p.s. Wobei mir jetzt gerade kommt, dass man zwischen einer Suche innerhalb des angezeigten Inhalts und einer Suche innerhalb vorhandener Daten unterscheiden und daraufhin auch das Anzeigetemplate abstimmen muss.

[jerch]

@jerch:
Ich denke, man muss zwischen der notwendigen Kürzung von Text und dem optionalen Gimmick einer Hervorhebung von Suchbegriffen unterscheiden. ...

Das ist klar, hab ich auch nur deshalb angesprochen, weil es als Nebenproblemin diesem Thread mehrfach aufgetaucht ist.

... Ist eine Hervorhebung von Suchergebnissen erwünscht, werden Suchergebnisse hervorgehoben. ...

Ok ich frage anders - welchen Sinn hat die Hervorhebung in der Liste von Einträgen Deiner Meinung nach, wenn
a.) der Benutzer weiss, wonach er gesucht hat bzw. man dies zusätzlich anzeigen könnte ("Suche: Wurzel \n Liste mit Einträgen")
b.) Kürzungen die Einträge "verstümmeln" (im Terminal ist sehr viel weniger Platz als in einem GUI-Fenster)

Hervorhebungen machen in meinen Augen nur Sinn, wenn man eine Information in einem größeren Datensatz visuell schneller erfassbar machen möchte. Deine Daten sind ja schon auf Eintragsebene strukturiert.

... Ist ja letztlich durch das Anlegen von Kategorien abgedeckt. Wenn ich also meinen Zahnarzt suche, kann ich ja alle Termine der Kategorie 'Arzttermine' anzeigen. #Hashtags, die innerhalb des eigentlichen #Textes gesetzt werden, halte ich neben der #Einführung von #RedBull für eine der #schlimmsten #Sünden neuerer #Zeit.

Das mit den Kategorien ist ein anderer Zugang zu den Daten. Entweder Du muss dem Nutzer das filterbar einstellen lassen können, oder die Kategorie belegt in der Ausgabe zusätzlich Platz.
Warum findest Du Hashtags so schlimm? Sie sind eine wunderbare Möglichkeit, den Nutzer Gewichtungen vornehmen zu lassen. Man muss sie ja in der Ausgabe nicht unbedingt so anzeigen.

p.s. Wobei mir jetzt gerade kommt, dass man zwischen einer Suche innerhalb des angezeigten Inhalts und einer Suche innerhalb vorhandener Daten unterscheiden und daraufhin auch das Anzeigetemplate abstimmen muss.

Siehe oben zur Sinnhaftigkeit der Hervorhebungen in der Eintragsliste