Entwickeln von unternehmenswichtiger Software mit Python: eine Erfolgsgeschichte

Ein Meer von Messungen

Seismische und Bohrungsmessdaten sind ein integraler Bestandteil der Datenbanken aller Öl- und Gasunternehmen. Sie werden auf verschiedene Weise verwendet, z. B. als Visualisierungen, zum Auffinden von Ressourcen und für die Inventur. Die Öl- und Gasbranche verfügt über eine lange und umfassende Geschichte der Computernutzung und digitalen Datenspeicherung. Im Lauf dieser Geschichte sind viele Standards für das Speichern der Messdaten entstanden, und die Unternehmen mussten sich für geeignete Standards entscheiden oder gar eigene entwickeln. Als Ergebnis entstand eine Vielfalt an Messdateien, die ähnlich wirken, jedoch häufig kleine aber entscheidende Unterschiede aufweisen.

Da schon seit langer Zeit Messinformationen anfallen, kann es nicht überraschen, dass für die Verarbeitung dieser Daten viele Werkzeuge verfügbar sind. Das Problem besteht darin, dass diese Werkzeuge häufig nicht Teil einer umfassenderen Softwarelösung sind. Sie wurden für die Anzeige oder bestimmte Verarbeitungsaspekte entwickelt, sind jedoch häufig nicht kompatibel mit dem Rest der Unternehmensdatenbank. Dies ist nicht optimal, da diese Daten nur dann vollständig genutzt werden können, wenn sie überlagert, integriert und gemeinsam analysiert werden können. Wenn davon ausgegangen wird, dass die meisten Öl- und Gasunternehmen den Esri Stack als wichtigste GIS-Software verwenden, scheint es wünschenswert, Bohrungs- und seismische Daten verschiedener Formate direkt in ArcGIS zu laden.

Entwickeln in einer Unternehmensumgebung – Warum Python?

Für die Entwicklung des Geodetics Tools hatten wir die Option, einen ArcObjects-basierten Ansatz zu verwenden, doch wir entschieden uns aus zwei wesentlichen Gründen für Python: 1) Entwicklungsgeschwindigkeit und 2) Einfache Bereitstellung.

Entwickeln in einer Unternehmensumgebung – Automatisierte Tests

Der Python-Code für die Geodetics Toolbox enthält weit mehr als 5000 Codezeilen (ohne Open Source-Pakete). Wie bei allen Handelsprodukten senden uns die Kunden regelmäßig Erweiterungsanfragen, die wir so schnell wie möglich umzusetzen versuchen. Die Anfragen reichen von neuen Parametern bis hin zu vollständig neuen Toolsets. Daher ist es uns wichtig zu wissen, ob sich Änderungen auf vorhandene Funktionen auswirken, und ob bestimmte Änderungen zum Fehlschlagen von Werkzeugen führen. Bei mehr als 40 Werkzeugen mit jeweils bis zu mehreren Dutzend Parametern ist ein manuelles Testen der einzelnen Werkzeuge schlicht ineffizient. Um die erwünschte Lieferzeit für die Anfragen unter Einhaltung der Qualitätsansprüche erfüllen zu können, sind automatisierte Tests ein absolutes Muss.

Python wird sozusagen "betriebsbereit geliefert", sodass wir für einen Teil der Lösung lediglich Python selbst prüfen mussten. Python verfügt über das hervorragende Standardmodul "unittest", das Bestandteil der Kerninstallation von Python ist. Wir verfügen für jedes Werkzeug über separate Testskripte, mit denen wir die vielen verschiedenen Permutationen der Parameter und Dateneingaben testen können. Dank der individuellen Testsuites für die einzelnen Werkzeuge können wir sehr präzise und im Laufe eines Arbeitstags zeitsparend und genau die gewünschten Aspekte testen.

Testsuites für die einzelnen Werkzeuge sind ein erster wichtiger Schritt. Es ist jedoch unerlässlich, dass diese Testskripte regelmäßig und automatisiert ausgeführt werden, und nicht nur dann, wenn es gerade jemandem einfällt. Mittlerweile ist es Mode geworden, eine "fortlaufende Integration" anzustreben, bei der nach jeder in die Codebasis eingecheckten Änderung alle Tests der Testsuite ausgelöst werden. Dies kann für einen bestimmten Typ von Codebasis oder manche Tests eine hervorragende Option sein. Für Werkzeuge mit großer Verarbeitungsauslastung wie z. B. Hochfrequenztests ist dies jedoch nicht immer praktisch. Wichtiger ist der Ansatz, den Test regelmäßig auszulösen. Dies kann nachts, wöchentlich oder gar monatlich in der Häufigkeit erfolgen, mit der die Codebasis aktualisiert wird. Wenn die Testsuite automatisch ausgeführt wird, haben Sie Ihren Code stets im Auge, sodass Sie gegebenenfalls rasch erkennen, ob und wann sich ein Fehler in den Code eingeschlichen hat, um diesen umgehend zu beheben.

Wiederverwenden von Code: Klassen in Python

Eine der Grundsätze beim Programmieren ist das Vermeiden von Doppelungen. Es gibt verschiedene Methoden, mit denen Sie Codedoppelungen vermeiden und Ihre Codebasis effizienter gestalten können. Zunächst können Sie Funktionen verwenden, die Codebestandteile enthalten, die Sie immer wieder verwenden. Funktionen sind äußerst hilfreich und der erste Schritt zum Vermeiden von Codedoppelungen. Bei einer großen Codebasis sind die Möglichkeiten (bei aller Berechtigung) begrenzt, sodass in vielen Fällen Klassen erstellt werden sollten.

Obwohl Python im Kontext der Software von Esri als Skriptsprache betrachtet wird (was z. B. im Namen "arcgisscripting" zum Ausdruck kommt), handelt es sich tatsächlich um eine vollständige objektorientierte Programmiersprache (OO). Daher können Programmierer Klassen sowie mithilfe von Vererbung vollständige Klassenhierarchien erstellen. In einer großen Codebasis kann sinnvoll geschriebener OO-Code beim konzeptionellen Abstrahieren komplexer Ideen, beim Verringern von Codedoppelungen und beim Isolieren von Code in kleine präzise Abschnitte helfen, die einfacher geändert, verwaltet und getestet werden können.

Das unten aufgeführte recht einfache Beispiel soll als erste Einführung in die Python-Klassen und eine kleine Klassenhierarchie dienen.

from os.path import basename

class AbstractReport(object):
    """
    Base parsing class
    """
    _table_fields = None

    def __init__(self, file_path, records):
        """
        initializes the class
        """
        self._file_path = file_path
        self._records = records

    def calc_coords(self):
        """
        calculates coordinates to be written to report table
        """
        raise NotImplementedError

    def write_table(self):
        """
        parses the records in the file
        """

        coords = self.calc_coords()
        print ('writes a table using fields %s '
               '\nand calculated coords %s to file %s' %
               (self._table_fields, coords, basename(self._file_path)))


class OrthoCheckReport(AbstractReport):
    """
    Orthongonal Check Report Class
    """
    _table_fields = ['FLD_A', 'FLD_B', 'FLD_C']

    def calc_coords(self):
        """
        calculates coordinates to be written to report table
        """
        print ('special Orthogonal Check report calculations using records %s' %
               self._records)
        return ['ortho', 'check', 'results']


class QAQCReport(AbstractReport):
    """
    QAQC Report class
    """
    _table_fields = ['FLD_X', 'FLD_Y', 'FLD_Z']

    def calc_coords(self):
        """
        calculates coordinates to be written to report table
        """
        print ('special QAQC report calculations using records %s' %
               self._records)
        return ['qaqc', 'report', 'results']


if __name__ == '__main__':
    input_file = r'c:\test\seismic_file.txt'
    records = ['reca', 'recb', 'recc']

    ocr = OrthoCheckReport(input_file, records)
    qqr = QAQCReport(input_file, records)

    ocr.write_table()
    qqr.write_table()

Beim Ausführen druckt dieser Code Folgendes:

special Orthogonal Check report calculations using records ['reca', 'recb', 'recc']
writes a table using fields ['FLD_A', 'FLD_B', 'FLD_C']
and calculated coords ['ortho', 'check', 'results'] to file seismic_file.txt

special QAQC report calculations using records ['reca', 'recb', 'recc']
writes a table using fields ['FLD_X', 'FLD_Y', 'FLD_Z']
and calculated coords ['qaqc', 'report', 'results'] to file seismic_file.txt

In der oben angeführten Hierarchie ist der Code für die write_table-Methode nur in einer der Klassen (der AbstractReport-Klasse) vorhanden. Instanzen der anderen Klassen ( OrthoCheckReport oder QAQCReport) können die Methode jedoch ebenfalls aufrufen. Dies liegt daran, dass sowohl OrthoCheckReport als auch QAQCReport "Unterklassen" der "Basisklasse" AbtractReport sind und von dieser "erben". Eine Unterklasse, die von einer Basisklasse erbt, verfügt über Zugriff auf alle Methoden und Eigenschaften der Basisklasse. Daher erfolgen Aufrufe an write_report unabhängig von der oben erstellten Klasse über dieselbe Methode.

Die calc_coords-Methode zeigt auf, was geschieht, wenn der Code in den Unterklassen sich von dem der Basisklasse unterscheiden muss. Die einzelnen Unterklassen verfügen über unterschiedliche Berechnungsverfahren für die für Tabellenkoordinaten und daher über eindeutigen Code. Um dies sicherzustellen "überladen" die Unterklassen die Methode calc_coords von der Basisklasse. Wie oben gezeigt erfolgt das "Überladen" in Python einfach durch das Hinzufügen einer Methode mit demselben Namen zu den Unterklassen. Dies bedeutet, dass die write_table-Methode beim Aufrufen von calc_coords einem eindeutigen Pfad durch die Unterklassen folgt, obwohl sie für alle Klassen über genau denselben Code verfügt. Dadurch wird der Code von unnötiger Logik (wie z. B. zusätzlichen "if"-Ausdrücken) befreit, sodass er optimiert und einfacher lesbar wird.

Damit eine Klasse von einer anderen erben kann, fügen Sie einfach den Namen der gewünschten Basisklasse in die Klassendeklaration ein:

class OrthoCheckReport(AbstractReport):

Stellen Sie hierbei sicher, dass die Initialisierung (__init__) der Unterklassen identisch mit der der Basisklasse ist. Wenn diese abweicht, müssen Sie auch für die Unterklassen eine "__init__" schreiben. In der Dokumentation und der Hilfe finden Sie Beispiele.

Verwenden und Bereitstellen von Open Source-Paketen

Zusammenfassung

Für die Bereitstellung der Funktionen der Geodetics Toolbox haben wir uns für Python als Entwicklungssprache entschieden. Python und das Geoverarbeitungs-Framework ermöglichten uns ein schnelles Bereitstellen der Funktionen, deren Erscheinungsbild und Funktionsweise dem Rest des ArcGIS-Produkts entsprachen. Mithilfe der Module, die Bestandteil jeder Python-Installation sind, konnten wir eine Suite von "unittests" erstellen, um die Qualität unseres Produkts über viele Codebereitstellungen und neue Funktionsanfragen hinweg sicherzustellen. Wir nutzten die Funktionen von Python als objektorientierte Programmiersprache, um Codedoppelungen in unserer Codebasis zu verringern, sodass der Code einfacher verwaltet werden kann. Abschließend konnten wir aufgrund der großen Open Source-Community von Python ein Open Source-Paket finden, das unsere Entwicklungszeit verkürzte und uns half, die Anforderungen des Kunden zu erfüllen.

Info zu Integrated Informatics

Integrated Informatics Inc. ist ein führendes Beratungsunternehmen für die Implementierung und Entwicklung von geographischen Informationssystemen. Integrated Informatics wurde 2002 gegründet und bietet mit Niederlassungen in Calgary (Alberta), St. John's (Neufundland) und Houston (Texas) die Verwaltung von räumlichen Daten und automatisierte Mapping-Lösungen für Kunden in Nordamerika an.

Integrated Informatics verfügt über langjährige Beziehungen zu den Kunden, die große und multinationale unabhängige Energieunternehmen und -organe, Kommunalverwaltungen, Landesregierungen sowie Entwicklungs- und Umweltberatungen umfassen. Wir verfügen über eine erfolgreiche Geschichte beim Entwickeln und Implementieren von Strategien, Systemen und Technologien, die die Unternehmensziele fördern und Unternehmenswerte schaffen.

Unsere Stärke sind unsere Mitarbeiter. Unser Team besteht aus erfahrenen Fachleuten auf den Gebieten geographische Informationssysteme, räumliche Datenverwaltung, Projektdatenmanagement und Anwendungsentwicklung sowie aus Experten verschiedener Disziplinen. Zu diesen Disziplinen gehören Pipelineentwicklung sowie Umwelt- und geowissenschaftliche Analyse. Unsere Arbeitsumgebung fördert Ideen, Innovationen und Implementierungen mithilfe professioneller Entwicklung, fortlaufender Weiterbildung, Branchenengagement und intern finanzierter Forschung und Entwicklung.

Integrated Informatics ist ein Silver Tier International Esri-Geschäftspartner, ein aktiver Teilnehmer am Beta-Programm für holistische Tests für Esri und Mitglied des Beirats für das GIS-Programm am Southern Alberta Institute of Technology (SAIT). Besuchen Sie uns unter www.integrated-informatics.com, oder wenden Sie sich unter gis@integrated-informatics.com an uns, um weitere Informationen über einzigartige Lösungen zu erhalten.