Das deutsche Python-Forum

Jedes mal wenn ich ein kleines Mini Programm schreibe, frage ich mich, wie ich die Konfigurationsdaten oganisieren könnte. In letzter Zeit mache ich oft sowas ähnliches:

Code: Alles auswählen

class Config(object):
    FOO = "Bar" # Hilfstext
    VAR1 = 123

Oft liegen Konfigurationsdaten als Textdateien in unterschiedlichen Formaten vor. Die meisten Linux Programme nutzten ein einfaches Text Format wie:

Code: Alles auswählen

# Das ist ein Kommentar, der meist über der jeweiligen Variable steht und diese beschreibt
VARIABLE1 = 123

Es gibt noch das INI Format oder XML Dateien (z.B. VirtualBox) oder sowas wie django's setup.py...

All diese Formate haben aber keine Metadaten zur Validierung der Eingangsdaten.

Wäre es nicht gut, wenn man mal ein einheitliches Format sich ausdenkt, welches So einfach lesbar ist, wie die Textdateien, aber auch von Programmen verarbeitet werden kann und Validierungs Daten enthält?

XML geht da ein wenig in die Richtung. Aber auch flach gehaltene XML Dateien sind nicht so einfach zu lesen, wie Textdateien.

Ein ähnliches Problem sehe ich bei Kommandozeilen Parameter. Es gibt dort auch zig verschiedene Formate, was die Angabe der Parameter angeht.

Würde es ein einheitliches Format für Konfigurationsdaten/Kommandozeilen Parameter geben, welches "Machinenlesbar" ist, könnte man sehr schnell GUIs/ncurses Oberflächen generieren.

Im Grunde kann django's form genau das:
1. Festlegen des Typs (Zahl, String usw.)
2. Daten zur Validierung (Zahl zwischen 1 und 10, oder String mit Länge von 5 bis 15 Zeichen usw.)
3. Hilfe Text
4. Generieren der Eingabe (Im Falle von form: HTML Form Felder)
5. Validieren der Eingabe und Rückmeldung von Fehler

In Python geht optparse und ConfigParser schon ein wenig die die Richtung.

Irgendwie kann ich mir aber nicht vorstellen, das es sowas nicht schon im Ansatz gibt. Weiß da jemand mehr?

Warum willst du in einer dynamisch typisierten Sprache die Config-Dateien statisch typisieren?

Wegen dieser Frage vermute ich auch mal, dass es so etwas (in Python) noch nicht gibt.

Alles außer der Typisierung geht mit ConfigObj.

Was hat das eine mit dem anderen zu tun???

Bei ANZAHL_MAX_VERBIDNUNGEN muß es halt eine Zahl zwischen 1 und X sein. Bei VERBINGUNGS_NAME muß es ein String sein...

Dazu reicht Validierung und man benötigt keine Typisierung

Wie gesagt, das geht mit ConfigObj

@Jens: Man würde da natürlich Daten und Meta-Daten (oder sogar Grammatiken) mit einander vermischen, wenn man beides in eine Datei schreibt. Also wäre das Konzept von XML mit XML-Schema da schon das, was Du jetzt schon für so etwas nutzen könntest.

Prinzipiell finde ich die Idee nicht schlecht, wobei mich das vor allem für JSON interessieren würde. Man könnte in einer Datei definieren, welche Elemente und Verschachtelungen erlaubt sind. Diese müßte man dann auswerten und anhand dieser Info die eigentliche Conig-Datei parsen.

Vorteil eines solchen Systems: Man kann automatisch Fehler in der Config-Datei ermitteln und muss diese nicht jedes Mal wieder separat im Programm abtesten.

@ice2k3: Dynamische Typisierung spielt bei der Eingabe von Parametern doch keine Rolle! Auch in einem Python Script will man das ein oder andere konsequent in einem Wertebereich haben.

Edit: Ok, wer suchet, der findet

http://pypi.python.org/pypi/json_schema/0.3

Hyperion hat geschrieben: @ice2k3: Dynamische Typisierung spielt bei der Eingabe von Parametern doch keine Rolle! Auch in einem Python Script will man das ein oder andere konsequent in einem Wertebereich haben.

Und mit einer Validierung überprüft man das und kann das ggf. behandeln.

Der Gedanke typisierter Konfigurationsdateien mit Python scheint mir einfach nicht richtig ...

ice2k3 hat geschrieben: Und mit einer Validierung überprüft man das und kann das ggf. behandeln.

Wie validiert man denn ohne "Typisierung"?

Der Gedanke typisierter Konfigurationsdateien mit Python scheint mir einfach nicht richtig ...

Vielleicht reden wir da an einander vorbei. Was genau verstehst Du in einer Config Datei unter Typisierung? Das Festlegen von Wertebereichen? Das erforderliche / optionale Auftreten von einem Key o.ä.?

Validierung ist implizit, Typisierung ist explizit

Bei Typisierung steht in der Configdatei noch, was das für ein Typ ist.

Bei Validierung überprüft man, ob der Wert einen bestimmten Typ hat.

(XML + Schema kann also auch reine Validierung sein)

Ja ich glaub wir reden ein bisschen aneinander vorbei. Der TS hat aber diese Unterscheidung schon eingeführt

Ich finde nicht, das ein einheitliches Format notwendig wäre.

Einfache Properties-Dateien lassen sich mit einem Einzeiler einlesen:

Code: Alles auswählen

    import re
    s = """
    ab.c = 3
    foo1 = bar
    """
    print dict(re.findall(r"([.\w]+)\s*=\s*(.*)", s))

Zumal gibt es immer die Möglichkeit, direkt Python zu benutzen.

Doch auch verschachtelte Datenstrukturen lassen sich relativ einfach einlesen:

Code: Alles auswählen

    import re
    s = """
    dependencies {
        dependency {
            groupId = org.junit
            artifactId = junit
            version = 4.7
        }
        dependency {
            groupId = org.hamcrest
            artifactId = hamcrest
            version = 1.1
        }
    }
    """
    class Element(object):
        def __init__(self, name):
            self.name, self.attr, self.children = name, {}, []
        def __repr__(self):
            return "%s { %s%s }" % (
                self.name, 
                "".join("%s = %s; " % i for i in self.attr.items()),
                " ".join(str(c) for c in self.children))

    elements = [Element("")]
    for m in re.finditer(r"([-.\w]+)\s*\{|([-.\w]+)\s*=\s*([^;]*);?|\}", s):
        if m.group(1):
            elements.append(Element(m.group(1)))
            elements[-2].children.append(elements[-1])
        elif m.group(2):
            elements[-1].attr[m.group(2)] = m.group(3)
        else:
            elements.pop()
    print elements[0]

Ob man Typen (auch "Zahl zwischen 1..5 sein" ist natürlich ein Typ) nun deklariert und von der Bibliothek prüfen lässt oder das selbst beim verarbeiten macht, ist kein so großer Unterschied. Ich glaube, wenn die Bibliothek das macht, sind gute Fehlermeldungen schwerer. XML würde ich meiden, denn der Parser für den DOM, den man dem fertigen XML-Parser nachlagern muss, ist auch nicht einfacher als was ich hier gezeigt habe.

Statische Typen sind natürlich hilfreich, wenn man automatisch Formulare generieren will. Da muss die Datenstruktur schon selbstbeschreibend sein, das ist klar. Ginge mit einem XML-Schema. Allerdings kann das beliebig kompliziert werden.

Zu Kommandozeilen-Parameter habe ich keine Meinung. Ich hätte gedacht, da gibt es schon eine Lösung in der Standardbibliothek.

Stefan

sma hat geschrieben: Ob man Typen (auch "Zahl zwischen 1..5 sein" ist natürlich ein Typ) nun deklariert und von der Bibliothek prüfen lässt oder das selbst beim verarbeiten macht, ist kein so großer Unterschied. Ich glaube, wenn die Bibliothek das macht, sind gute Fehlermeldungen schwerer.

Hm... bist Du Dir da sicher? Wenn man ein (Standard)-Format für unterschiedliche Scripte erstellt, dann wäre es doch praktisch das Parsen und Validieren zu zentralisieren. Nichts anderes wird es doch bei vielen Libs auch sein, ob nun Bildverarbeitung, Compiler-Geschichten o.ä.

Das deutsche Python-Forum

Konfigurationsdaten/Kommandozeilen Parameter oganisieren...

Konfigurationsdaten/Kommandozeilen Parameter oganisieren...