Python: Best Practice zum Einbinden einer Versionsnummer in eine App?

Question

Ich habe eine PyQt-Anwendung, die Datendateien liest und schreibt. Ich füge eine "Versionsnummer" in jede geschriebene Datei ein. Dies ist eine einfache Zahl ähnlich wie: 1.2 oder etwas (Haupt- und Nebenversionen).

Ich mache dies, damit ich das Format dieser Datendateien in zukünftigen Versionen ändern kann und sie dann immer noch korrekt parse, indem ich einfach überprüfe, was die Version in der Datei ist.

Meine Frage ist, was ist die beste Vorgehensweise für das Speichern dieser Nummer in der App selbst gespeichert. I.e. kann ich die Versionsnummer der App nur in die Klasse schreiben, die für das Lesen und Schreiben von Dateien zuständig ist? Oder sollte ich irgendeine Art von Objekt/Variable auf der obersten Ebene der App gespeichert haben und irgendwie darauf von der Klasse zugreifen, die für das Lesen und Schreiben dieser Dateien verantwortlich ist. Wenn Letzteres, wie kann ich es speichern und wie kann ich darauf zugreifen?

Danke.

Answer 1

Persönlich würde ich es manuell so nicht tun. Ich würde meinen Code in Subversion speichern und die Revisionsnummern für mich beibehalten lassen.

Answer 2

Viele Open-Source-Projekte (z. B. numpy, Fabric) haben ein Modul namens "version", das Versionsinformationen in Variablen der obersten Ebene enthält. Siehe z.B. fabric's version file.

Answer 3

Erstens, Version das Datenformat getrennt von der App, wenn dies nicht bereits geschehen. Zweitens, separate Klassen für neuere Versionen des Formats. Wenn das Format vollständig abwärtskompatibel ist, können Sie die Klassen für ältere Versionen löschen.

• DF
  • __init__.py
  • dfbase.py
  • V1_1
    • __init__.py
    • format.py
    : Wie für die Dateistruktur, könnten Sie so etwas wie haben
  • v2_0
    • __init__.py
    • format.py

wo "df" für das Datenformat Name steht. Die Paketinitialisierungsdateien importieren die entsprechenden Pakete und definieren eine Struktur oder Funktion, um sie zugänglich zu machen. Die oberste Ebene __init__.py sollte außerdem eine Factory-Funktion zum Erstellen von Datenformatobjekten definieren, sodass Sie nicht müssen.

DF/__ init__.py:

from df.dfbase import DFBase 
from v1_1 import DF as DF1 
from v2_0 import DF as DF2 
versions = { 
    '1.0': DF1, # let's say minor versions are fully backwards compatible 
    '1.1': DF1, 
    '2.0': DF2 
} 
def create(file): 
    """Factory function. Loads data from 'file', returns a DF of the appropriate 
    version. 
    """ 
    ... 

DF/V1_1/__ init__.py:

__version__ = '1.1' 
# previous versions that this one is backwards compatible with 
previous = ['1.0'] 
from format import DF 

DF/V1_1/Format.py:

from df import DFBase 

class DF(DFBase): 
    ... 

DF/v2_0/__ init__.py:

__version__ = '2.0' 
from format import DF 

Mit etwas mehr Codierung in DF/__ init__.py, könnten Sie die Einfuhr und Registrierung von Formatversionen automatisieren.

import glob, sys 
from ndf.ndfbase import NDFBase 

formats={} 

for ver in glob.iglob('v*_*'): 
    pkg = '{0}.{1}'.format(__package__, ver) 
    __import__(pkg) 
    formats[sys.modules[pkg].__version__] = sys.modules[pkg] 
    if hasattr(sys.modules[pkg], 'previous'): 
     for prev in sys.modules[pkg].previous: 
      formats[prev] = sys.modules[pkg] 

def create(file): 
    """Factory function. Loads data from 'file', returns a DF of the appropriate 
    version. 
    """ 
    ...