Die aktuellen Daten kartieren

Korallen brauchen Algen, um zu überleben. Ist die Meerestemperatur zu warm oder zu kalt, kann dies einen Rückgang der Algen zur Folge haben, der zum Ausbleichen der Korallen und zu einer erhöhten Mortalitätsrate führt. Das Coral Reef Watch Program der NOAA stellt globale Daten zum Risiko der Korallenbleiche bereit. Diese Daten werden häufig aktualisiert.

In dieser Lektion rufen Sie mit ArcGIS Pro und Python die aktuellen Daten zur Korallenbleiche als JSON-Datei ab. Anschließend erstellen Sie zwei Features-Classes auf der Basis der Daten, ändern deren Symbolisierung und veröffentlichen sie. In späteren Lektionen entwickeln Sie eine Feed-Routine, damit diese Layer und Services automatisch aktualisiert werden, wenn neue Daten verfügbar sind.

ArcPy und die ArcGIS API for Python importieren

Als Erstes öffnen Sie ein neues Projekt in ArcGIS Pro und ändern dessen Grundkarte. Anschließend verwenden Sie Python, um ArcPy und die ArcGIS API for Python zu importieren.

ArcPy ist ein Python-Site-Paket. Es ermöglicht Ihnen die Verwendung von Python zur Ausführung von Geoverarbeitungswerkzeugen und anderen ArcGIS-Funktionen. Die ArcGIS API for Python ist eine Python-Bibliothek; auch sie ermöglicht Python die Ausführung von GIS-Tasks. Später stellen Sie damit eine Verbindung mit ArcGIS Online oder ArcGIS Enterprise her.

  1. Starten Sie ArcGIS Pro. Melden Sie sich mit Ihrem lizenzierten ArcGIS- oder einem Named-User-Konto beim ArcGIS Enterprise-Portal an, falls Sie dazu aufgefordert werden.
    Hinweis:

    Wenn Sie nicht über ArcGIS Pro verfügen, können Sie sich für eine kostenlose Testversion von ArcGIS registrieren. Wenn Sie sich bei einem Enterprise-Konto anmelden, dann müssen Sie sicherstellen, dass ArcGIS Pro für die Verwendung des Portals Ihrer Organisation konfiguriert ist.

  2. Klicken Sie unter Leere Vorlagen auf Karte.

    Vorlage "Karte"

  3. Geben Sie im Fenster Neues Projekt erstellen unter Name den Text Coral Bleaching ein. Klicken Sie auf OK.

    In ArcGIS Pro wird ein leeres Kartenprojekt geöffnet. Je nach den Einstellungen Ihrer Organisation kann die Standardausdehnung variieren. Zuerst legen Sie eine Grundkarte fest, auf der Ihre Daten hervorgehoben werden.

  4. Klicken Sie auf dem Menüband auf die Registerkarte Karte. Klicken Sie in der Gruppe Layer auf Grundkarte, und wählen Sie Hellgraue Hintergrunddarstellung aus.

    Grundkartenoption "Hellgrauer Hintergrund"

    Die Grundkarte wird der Karte und dem Bereich Inhalt hinzugefügt. Die Grundkarte enthält zudem einen Referenz-Layer mit Ortsnamen. Da Sie diesen Referenz-Layer nicht benötigen, deaktivieren Sie ihn.

  5. Deaktivieren Sie im Bereich Inhalt den Layer Hellgraue Referenzkarte.

    Deaktivierter Layer "Hellgraue Referenzkarte" im Bereich "Inhalt"

    Anschließend öffnen Sie das Fenster Python.

    ArcGIS Pro wird über die Anaconda Distribution mit Python 3 ausgeliefert. Die Anaconda Distribution enthält viele gängige Python-Module, die in datenwissenschaftlichen Anwendungen verwendet werden.

  6. Klicken Sie im Menüband auf die Registerkarte Analyse. Klicken Sie in der Gruppe Geoverarbeitung auf Python.

    Schaltfläche "Python" auf der Registerkarte "Analyse"

    Das Fenster Python wird angezeigt. Das Fenster besteht aus zwei Teilen: der Python-Eingabeaufforderung und dem Protokoll. An der Python-Eingabeaufforderung geben Sie den Python-Code ein. Das Protokoll enthält eine Aufzeichnung des eingegebenen Python-Codes.

    Führen Sie zunächst eine einfache Zeile mit Python-Code aus, um sich mit der grundlegenden Python-Syntax vertraut zu machen.

    Tipp:

    Sie können das Fenster Python beliebig positionieren und dessen Größe anpassen. Ziehen Sie an der Titelleiste, um den Bereich neu zu positionieren, bzw. an den Kanten, um die Größe anzupassen. Sie können ihn auch an verschiedenen Stellen in ArcGIS Pro verankern.

  7. Klicken Sie in die Python-Eingabeaufforderung (wo Python-Code hier eingeben angezeigt wird), geben Sie print('Hello World!') ein, und drücken Sie die Eingabetaste.

    Protokoll mit der Funktion "print"

    Die Funktion print() bewirkt, dass das Protokoll den Text in Klammern anzeigt. In diesem Fall ist print() die Funktion und 'Hello World!' das Argument (eine Variable oder Eingabe für die Funktion).

    Viele Python-Funktionen können ausgeführt werden, indem Sie den Namen der Funktion eingeben und in Klammern ein Argument hinzufügen. Nicht alle Python-Funktionen benötigen ein Argument, während andere mehrere Argumente erfordern (getrennt durch Kommas).

    Funktionen geben einen Wert im Protokoll zurück. Anweisungen dagegen führen einen Prozess aus, ohne einen Wert zurückzugeben. Um Module (z. B. ArcPy) zu importieren, verwenden Sie keine Funktion, sondern eine Anweisung. Als Erstes importieren Sie das sys-Modul. Dieses Modul stellt mehrere systemspezifische Funktionen bereit.

  8. Geben Sie an der Python-Eingabeaufforderung import sys ein, und drücken Sie die Eingabetaste.

    Das sys-Modul wird importiert. Als Nächstes zeigen Sie mithilfe des version-Attributs Ihre Python-Version an. Attribute sind Eigenschaften von Python-Objekten (Funktionen, Variablen oder Konstanten). Sie können mit einem Punkt an Python-Objekte angehängt werden.

  9. Geben Sie sys.version ein, und drücken Sie die Eingabetaste.

    Protokoll mit den Zeilen "import sys" und "sys.version"

    In diesem Fall ist die Funktion sys das Objekt und version dessen Attribut.

    Das Protokoll gibt Informationen über Ihre Python-Version zurück. In der Beispielabbildung lautet die Version 3.6.6. Abhängig von Ihrer ArcGIS Pro-Version kann Ihre Version davon abweichen.

    Mit ArcPy können Sie ArcGIS-Geoverarbeitungswerkzeuge an der Python-Eingabeaufforderung ausführen. Sie importieren nun das arcpy-Modul auf die gleiche Weise wie das sys-Modul.

  10. Geben Sie an der Python-Eingabeaufforderung import arcpy ein, und drücken Sie die Eingabetaste.

    Das arcpy-Modul wird importiert.

  11. Geben Sie help(arcpy) ein, und drücken Sie die Eingabetaste.

    Protokoll mit den Zeilen "import arcpy" und "help(arcpy)"

    Mit der Funktion help() können Sie Informationen über das jeweilige Argument (arcpy) abrufen. In diesem Fall wurde eine große Menge an Informationen hinzugefügt. Sie können die Größe des Python-Fensters anpassen, um alle Informationen sehen zu können.

    Als Nächstes importieren Sie die ArcGIS API for Python mithilfe des arcgis-Moduls.

  12. Geben Sie an der Python-Eingabeaufforderung import arcgis ein, und drücken Sie die Eingabetaste.

    Die ArcGIS API for Python wird importiert.

    Hinweis:

    Wenn Sie die Meldung ModuleNotFoundError erhalten, während Sie das arcgis-Modul importieren, ist die ArcGIS API for Python möglicherweise nicht auf Ihrer ArcGIS Pro-Instanz installiert. Um sie zu installieren, klicken Sie auf die Registerkarte Projekt und dann auf die Registerkarte Python. Klicken Sie auf Pakete hinzufügen, und suchen Sie nach arcgis. Klicken Sie in der Liste der Suchergebnisse auf das arcgis-Paket, und klicken Sie dann auf Installieren. In den Anweisungen zum Installieren und Einrichten wird die Installation der ArcGIS API for Python ausführlicher beschrieben.

  13. Geben Sie help(arcgis) ein, und drücken Sie die Eingabetaste.

    Protokoll mit den Zeilen "import arcgis" und "help(arcgis)"

    Es werden Informationen zum arcgis-Modul angezeigt.

Eine Datei herunterladen

Im nächsten Schritt laden Sie räumliche Daten im JSON-Format aus dem Coral Reef Watch Program der NOAA herunter. Diese Daten enthalten aktuelle Informationen über das Risiko der Korallenbleiche.

Die Daten werden auf der Coral Reef Watch Website gehostet. Zum Abrufen der Daten verwenden Sie verschiedene Funktionen. Diese Funktionen erfordern, dass Sie zunächst die entsprechenden Module importieren.

  1. Führen Sie an der Python-Eingabeaufforderung die folgende Zeile aus:
    import os, tempfile

    Die Module os und tempfile werden importiert. Darüber hinaus importieren Sie das Submodul request des Moduls urllib.

  2. Führen Sie die folgende Zeile aus:
    from urllib import request

    Das Submodul request beinhaltet die Funktion urlretrieve, mit der Sie die Daten abrufen können. Für die Funktion urlretrieve sind zwei Variablen erforderlich: die URL der Online-Datei (url) und deren Speicherort auf Ihrem Computer (filename).

    In Python werden Variablen mit einem Gleichheitszeichen (=) definiert und zugewiesen. Um die Variable filename zu definieren, führen Sie die Funktion os.path.join() aus, um ein temporäres Verzeichnis (temp_dir) mit dem vorgesehenen Namen der Datei zu verbinden. Um das temporäre Verzeichnis zu definieren, führen Sie die Funktion tempfile.mkdtemp() aus.

    Hinweis:

    Bei der Variablen filename kann es sich um einen beliebigen Pfad handeln, der auf einen Speicherort auf Ihrem Computer verweist. Es empfiehlt sich jedoch, die Datei in einem temporären Verzeichnis zu speichern. Die Funktion os.path.join() wird verwendet, da sie auf jedem Betriebssystem ausgeführt werden kann, unabhängig davon, mit welchem Zeichen die Ordner im Dateipfad getrennt werden.

  3. Führen Sie die folgenden Zeilen aus (um alle auf einmal auszuführen, können Sie die Zeilen kopieren und einfügen):
    url = 'https://coralreefwatch.noaa.gov/vs/vs_polygons.json'
    temp_dir = tempfile.mkdtemp()
    filename = os.path.join(temp_dir, 'latest_data.json')
    response = request.urlretrieve(url, filename)

    Diese Zeilen definieren alle erforderlichen Variablen. Um den Pfad der abgerufenen JSON-Datei zu überprüfen, führen Sie die Funktion print mit filename als Argument aus.

  4. Führen Sie die folgende Zeile aus:
    print(filename)

    Protokoll mit dem Pfad zu den aktuellen Daten

    In der Beispielabbildung enthält die letzte Zeile den Pfad zur Datei latest_data.json, die Sie abgerufen haben (Ihr Pfad kann von dem in der Abbildung abweichen). Sie können den Dateinamen kopieren und im Datei-Explorer Ihres Computers (z. B. Windows Explorer) einfügen, um die Datei zu öffnen. Die Datei kann in einem beliebigen Texteditor geöffnet werden.

    Als Nächstes erstellen Sie eine data_raw-Variable, um die Daten im JSON-Format darzustellen. Sie verwenden diese Variable immer dann, wenn Sie in einer Codezeile auf die JSON-Daten verweisen. Um die Variable zu erstellen, müssen Sie das json-Modul importieren, damit Sie die Funktion json.load() ausführen können. Darüber hinaus müssen Sie eine Zwischenvariable namens json_file erstellen, die Ihre Datei öffnet.

  5. Führen Sie die folgenden Zeilen aus:
    import json
    json_file = open(filename)
    data_raw = json.load(json_file)

    Obwohl das Protokoll es nicht anzeigt, wird die Variable json_file (Ihre JSON-Datei) geöffnet; gleichzeitig wird die Variable data_raw geladen.

    Hinweis:

    Die Variable json_file bleibt geöffnet, bis der Befehl json_file.close() ausgeführt wird. Alternativ können Sie die Datei auch mit einer with-Anweisung öffnen. Dadurch wird die Datei automatisch geschlossen, nachdem der Codeblock abgeschlossen wurde. Die folgenden Codezeilen stellen dar, wie die json_file-Variable mit einer with-Anweisung geöffnet werden kann:

    with open(filename) as json_file:
        data_raw = json.load(json_file)    # Do something with the 'data_raw' variable
    # Do something else outside the 'with' section. The json_file variable is now closed.

    Zeilen, die mit dem Rautenzeichen (#) beginnen, sind Kommentare, die sich nicht auf den Code auswirken, sondern lediglich Informationszwecken dienen.

Layer aus der Datei erstellen

Um die heruntergeladenen Daten zu visualisieren (und sich mit der Verwendung von Python zur Interaktion mit räumlichen Daten vertraut zu machen), erstellen Sie auf der Grundlage der JSON-Datei zwei Feature-Classes.

Zuerst erstellen Sie eine neue File-Geodatabase, die die Feature-Classes enthält. Da die Datei Daten für Punkt- und Polygon-Features enthält, unterteilen Sie sie in zwei JSON-Dateien, eine für jeden Feature-Typ. Anschließend erstellen Sie für jede JSON-Datei eine Feature-Class und speichern diese in der Geodatabase.

Die Funktion zur Erstellung der Geodatabase (arcpy.management.CreateFileGDB) erfordert, wie die Funktion urlretrieve, einen Pfad und einen Namen. Sie führen zudem die Funktion arcpy.env.workspace aus, um die Geodatabase als Standard-Workspace festzulegen.

  1. Erstellen Sie auf Laufwerk C: Ihres Computers einen Ordner namens Temp.
  2. Führen Sie an der Python-Eingabeaufforderung die folgenden Zeilen aus:
    arcpy.management.CreateFileGDB(r'C:\Temp', 'Live.gdb')
    arcpy.env.workspace = os.path.join(r'C:\Temp', 'Live.gdb')

    Die Live-Geodatabase wird im Ordner "Temp" erstellt (um dies zu überprüfen, können Sie den Ordner öffnen). Als Nächstes erstellen Sie zwei Wörterbücher: eins für Punkt-Features (Stationen) und eins für Polygon-Features (von der NOAA festgelegte Interessenbereiche).

    In Python sind Wörterbücher Sammlungen von unsortierten, indizierten Elementen. Die von Ihnen erstellten Wörterbücher beinhalten, wie durch das GeoJSON-Dateiformat vorgeschrieben, zwei Elemente. Das type-Element bezieht sich auf den Geometrietyp in der data_raw-Variablen (Ihrer JSON-Datei). Das features-Element listet die Features auf. Im Moment ist die Liste noch leer, was durch das Klammerpaar angezeigt wird.

  3. Führen Sie die folgenden Zeilen aus:
    data_stations = dict(type=data_raw['type'], features=[])
    data_areas = dict(type=data_raw['type'], features=[])

    Protokoll mit Zeilen zum Erstellen von Wörterbüchern

    Die Wörterbücher werden erstellt. Als Nächstes laden Sie die Features in der data_raw-Variablen je nach Geometrietyp des Features in die Bibliothek data_stations oder data_areas.

    Als Erstes erstellen Sie eine for-Schleife. Eine for-Schleife führt eine Funktion oder Anweisung für jedes Element in der Liste aus. Sie erstellen eine Schleife, die alle Features in der data_raw-Variablen durchläuft. Indem Sie eine bedingte if-Anweisung erstellen, bestimmen Sie den Geometrietyp jedes Features. Anschließend verwenden Sie die Methode append(), um Features mit einem bestimmten Geometrietyp an die Liste der Features der entsprechenden Bibliothek anzuhängen.

  4. Führen Sie die folgenden Zeilen aus:
    for feat in data_raw['features']:
        if feat['geometry']['type'] == 'Point':
            data_stations['features'].append(feat)
        else: # elif feat['geometry']['type'] in ['MultiPolygon', 'Polygon']:        
            data_areas['features'].append(feat)
    Vorsicht:

    Die Python Software Foundation empfiehlt, Leerzeichen anstelle von Tabulatoren zu verwenden, um Codezeilen einzurücken. Verwenden Sie beim Einrücken keine Mischung aus Tabulatoren und Leerzeichen, da der Code sonst nicht korrekt ausgeführt werden kann.

    Für jedes in den JSON-Daten aufgelistete Feature gilt: Features mit dem Geometrietyp "Punkt" werden an die Bibliothek data_stations angehängt. Weisen Features dagegen den Geometrietyp "Polygon" oder "Multipolygon" auf, werden sie an die Bibliothek data_areas angehängt.

    Sie führen die Funktion len() aus, wobei Sie die Liste data_stations['features'] verwenden, um zu überprüfen, wie viele Features in die Liste geladen wurden.

  5. Führen Sie die folgende Zeile aus:
    len(data_stations['features'])

    Protokoll mit der Funktion "len()" zum Zählen der Stationen

    Die Zeile gibt die Zahl 213 zurück, d. h. es gibt 213 Punkt-Features. Die Polygon-Features in der JSON-Datei entsprechen den von der NOAA festgelegten Interessenbereichen. Da sich diese Bereiche regelmäßig ändern, lassen sie sich nicht so leicht überprüfen wie die Stationen.

    Stattdessen greifen Sie auf den Namen und die Koordinaten des zehnten Features in der Liste zu. In Python beginnen Listen mit 0 statt mit 1, d. h. das zehnte Feature ist Feature 9.

  6. Führen Sie die folgende Zeile aus:
    data_areas['features'][9]['properties']['name']

    Das Protokoll gibt den Namen des zehnten Features zurück.

  7. Führen Sie die folgende Zeile aus:
    data_areas['features'][9]['geometry']['coordinates']

    Das Protokoll gibt eine lange Liste mit Koordinaten zurück, die den Stützpunkten des Polygons entsprechen.

    Hinweis:

    Da diese Daten regelmäßig aktualisiert werden, können Ihre Ergebnisse von der Beispielabbildung abweichen.

    Protokoll mit den Namen und Koordinaten des Features "Beagle Gulf"

    Als Nächstes speichern Sie die Wörterbücher als JSON-Dateien in demselben temporären Verzeichnis, in dem Sie die ursprüngliche JSON-Datei (temp_dir) gespeichert haben. Sie führen die Funktion os.path.join() aus, um Dateipfade für jede neue JSON-Datei zu erstellen. Anschließend erstellen Sie with-Anweisungen und verwenden die Funktion json.dump(), um die Wörterbücher als JSON-Dateien zu speichern.

  8. Führen Sie die folgenden Zeilen aus (die Kommentare sind optional):
    # Filenames of temp json files 
    stations_json_path = os.path.join(temp_dir, 'points.json')
    areas_json_path = os.path.join(temp_dir, 'polygons.json')
    # Save dictionaries into json files
    with open(stations_json_path, 'w') as point_json_file:
        json.dump(data_stations, point_json_file, indent=4)
    with open(areas_json_path, 'w') as poly_json_file:
        json.dump(data_areas, poly_json_file, indent=4)

    Sie führen die Funktion print() für jeden Pfad aus, um zu überprüfen, ob die Dateien korrekt gespeichert wurden.

  9. Führen Sie die folgende Zeile aus:
    print(stations_json_path)
  10. Führen Sie die folgende Zeile aus:
    print(areas_json_path)
    Hinweis:

    Ihr Dateipfad kann von dem Pfad in der Beispielabbildung abweichen.

    Protokoll mit "print()"-Funktionen für jede JSON-Datei

    Jeder Pfad führt zu Ihrem "Temp"-Ordner. Die Dateinamen, die Sie bei der Ausführung der Funktion os.path.join() angegeben haben, lauten "points.json" und "polygons.json". Bei Bedarf können Sie jeden Pfad kopieren und die Dateien in einem beliebigen Texteditor öffnen.

    Nachdem die JSON-Dateien erstellt wurden, konvertieren Sie diese in Feature-Classes, indem Sie die Funktion arcpy.conversion.JSONToFeatures() ausführen. Für diese Funktion ist der Pfad zur JSON-Datei und der Name der zu erstellenden Feature-Class erforderlich.

  11. Führen Sie die folgenden Zeilen aus:
    # Convert JSON files to features
    arcpy.conversion.JSONToFeatures(stations_json_path, 'alert_stations') 
    arcpy.conversion.JSONToFeatures(areas_json_path, 'alert_areas')

    Die Feature-Classes werden im Standard-Workspace, d. h. in diesem Fall in der von Ihnen angegebenen Live-Geodatabase, gespeichert. Zwei Layer, "alert_stations" und "alert_areas", werden der Karte hinzugefügt.

    Karte mit Stationen und Bereichen

Die Symbolisierung ändern

Sie können Python auch verwenden, um die Layer-Symbolisierung zu aktualisieren. Dies ist für die Erstellung einer Feed-Routine zwar nicht erforderlich, aber es empfiehlt sich, die Daten auf visuell ansprechende und aussagekräftige Weise darzustellen. Darüber hinaus kann der zum Ändern der Symbolisierung erstellte Code schnell angepasst werden, wenn Sie die Symbolisierung zu einem späteren Zeitpunkt ändern möchten.

Sie symbolisieren die Layer basierend auf der Warnungsebene, die, je nach aufgezeichneter Hitzebelastung, von 0 bis 4 reicht. Niedrigere Warnungsebenen sind blau, höhere Warnungsebenen dagegen rot. Die Layer enthalten Textfelder für die Warnungsebene, aber damit eine abgestufte Symbolisierung möglich ist, muss es sich um numerische Felder handeln.

Als Erstes erstellen Sie mithilfe der Funktion arcpy.management.AddField ein neues numerisches Feld für die Warnungsebene. Für das Argument dieser Funktion listen Sie zuerst den Layer auf, dem das Feld hinzugefügt werden soll, dann den Namen des Feldes, dann den Datentyp und den Feldalias. Sie können weitere Einstellungen angeben, aber erforderlich sind für diese Felder nur die oben aufgeführten.

  1. Führen Sie an der Python-Eingabeaufforderung die folgenden Zeilen aus:
    # Add alert_level field
    arcpy.management.AddField('alert_stations', 'alert_level', 'SHORT', field_alias='Alert Level')
    arcpy.management.AddField('alert_areas', 'alert_level', 'SHORT', field_alias='Alert Level')

    Sowohl dem Layer "alert_stations" als auch dem Layer "alert_areas" wird ein alert_level-Feld hinzugefügt. Beide Felder weisen den Datentyp "Short Integer" (einen numerischen Datentyp) und den Alias Alert Level auf.

    Als Nächstes berechnen Sie die neuen Felder mit der Funktion arcpy.management.CalculateField. Diese Funktion verwendet den Layer-Namen und den Feldnamen als als Argumente und einen Ausdruck zur Berechnung des Feldes. Ihr Ausdruck konvertiert die Werte des Textfeldes alert mithilfe der Funktion int() in ganze Zahlen.

  2. Führen Sie die folgenden Zeilen aus:
    # Calculate alert_level field
    arcpy.management.CalculateField('alert_stations', 'alert_level', "int(!alert!)")
    arcpy.management.CalculateField('alert_areas', 'alert_level', "int(!alert!)")

    Die Felder werden berechnet.

    Tipp:

    Wenn Sie überprüfen möchten, ob die Felder korrekt berechnet wurden, klicken Sie mit der rechten Maustaste auf den Layer alert_stations oder den Layer alert_areas, und wählen Sie Attributtabelle aus. Führen Sie einen Bildlauf bis zum Ende der Tabelle durch, und stellen Sie sicher, dass ein Alert Level-Feld mit Werten zwischen 0 und 4 hinzugefügt wurde.

    Basierend auf dem neuen Feld ändern Sie nun die Symbolisierung für den Layer "alert_stations". Zuerst erstellen Sie Variablen, die das aktuelle Projekt (p) und die Karte (m) darstellen. Außerdem erstellen Sie Variablen für den Layer "alert_stations" (points_lyr) und dessen Symbolisierung (points_sym).

  3. Führen Sie die folgenden Zeilen aus:
    # Symbology
    p = arcpy.mp.ArcGISProject("CURRENT")
    m = p.listMaps('Map')[0]
    # Points
    points_lyr = m.listLayers('alert_*')[0]
    points_sym = points_lyr.symbology

    Als Nächstes aktualisieren Sie den Renderer. Die Symbole werden derzeit mit dem SimpleRenderer-Typ gerendert (Einzelsymbol). Um die Features auf der Grundlage eines Feldes unterschiedlich zu symbolisieren, ändern Sie den Renderer in GraduatedSymbolsRenderer (abgestufte Symbole).

    Darüber hinaus legen Sie fest, dass der Renderer das Feld alert_level als Klassifizierungsfeld verwendet und die Daten in vier Klassen sortiert (0 bis 1, 1 bis 2, 2 bis 3 und 3 bis 4). Sie legen die Größe und Farbe für jede Klasse so fest, dass die Größe mit höherer Warnungsebene zunimmt und sich die Farbe von Blau in Rot ändert.

  4. Führen Sie die folgenden Zeilen aus:
    # Always change to the GraduatedSymbolsRenderer from the SimpleRenderer
    if points_sym.renderer.type != 'SimpleRenderer':
        points_sym.updateRenderer('SimpleRenderer')
    points_sym.updateRenderer('GraduatedSymbolsRenderer')
    points_sym.renderer.classificationField = 'alert_level'
    points_sym.renderer.breakCount = 4
    points_labels = ['0 - 1', '> 1 - 2', '> 2 - 3', '> 3 - 4']
    points_upperBounds = [1, 2, 3, 4]
    points_sizes = [6, 16.50, 27, 37.50] 
    layers_colors = [{'RGB': [5, 113, 176, 40]}, {'RGB': [146, 197, 222, 50]},
                       {'RGB': [244, 165, 130, 50]}, {'RGB': [202, 0, 32, 30]}]

    Als Nächstes erstellen Sie eine for-Schleife, um die festgelegten Größen und Farben auf jede Klasse anzuwenden. Ihre Klassen sind in einer numerischen Liste von 1 bis 4 enthalten. Sie verwenden i (für "Integer") als Platzhaltervariable, um die nummerierten Klassen darzustellen.

  5. Führen Sie die folgenden Zeilen aus:
    for i in range(4):
        item = points_sym.renderer.classBreaks[i]
        item.symbol.applySymbolFromGallery('Circle', 1)
        item.label = points_labels[i]
        item.upperBound = points_upperBounds[i]
        item.symbol.size = points_sizes[i]
        item.symbol.color = layers_colors[i]

    Diese Schleife durchläuft alle ganzen Zahlen im angegebenen Bereich (4). Für die erste ganze Zahl werden die erste Beschriftung sowie jeweils der obere Grenzwert, die Größe und die Farbe in den zuvor erstellten Listen verwendet. Für die zweite ganze Zahl wird die zweite Reihe von Werten verwendet usw., bis das Ende des Bereichs erreicht ist.

    Abschließend führen Sie eine Zeile aus, um die Symbolisierung des Layers basierend auf den zuvor ausgeführten Zeilen zu aktualisieren.

  6. Führen Sie die folgenden Zeilen aus:
    # Update
    points_lyr.symbology = points_sym

    Die Symbolisierung wird aktualisiert. (Wenn Ihre Quelldaten aktueller sind, kann Ihre Karte von der Beispielabbildung abweichen).

    Karte mit aktualisierter Punkt-Symbolisierung

    Sie können ähnlichen Code verwenden, um die Symbolisierung des Layers "alert_areas" zu ändern. Zunächst erstellen Sie dafür Variablen für den Layer (polygons_lyr) und dessen Symbolisierung (polygons_sym).

  7. Führen Sie die folgenden Zeilen aus:
    # Polygons
    polygons_lyr = m.listLayers('alert_*')[1]
    polygons_sym = polygons_lyr.symbology

    Als Nächstes aktualisieren Sie den Renderer und erstellen vier Klassen, die den für den Punkt-Layer erstellten Klassen entsprechen.

  8. Führen Sie die folgenden Zeilen aus:
    # Always change to the GraduatedSymbolsRenderer from the SimpleRenderer
    if polygons_sym.renderer.type != 'SimpleRenderer':
        polygons_sym.updateRenderer('SimpleRenderer') 
    polygons_sym.updateRenderer('GraduatedColorsRenderer')
    polygons_sym.renderer.classificationField = 'alert_level'
    polygons_sym.renderer.breakCount = 4
    polygons_labels = ['0 - 1', '> 1 - 2', '> 2 - 3', '> 3 - 4']
    polygons_upperBounds = [1, 2, 3, 4]
    layers_colors = [{'RGB': [5, 113, 176, 40]}, {'RGB': [146, 197, 222, 50]},
                       {'RGB': [244, 165, 130, 50]}, {'RGB': [202, 0, 32, 30]}]

    Zuletzt erstellen Sie eine Schleife, um die Beschriftungen, die Größe und die Farbe jeder Klasse zu ändern und die Layer-Symbolisierung zu aktualisieren.

  9. Führen Sie die folgenden Zeilen aus:
    for i in range(4):
        item = polygons_sym.renderer.classBreaks[i]
        item.label = polygons_labels[i]
        item.upperBound = polygons_upperBounds[i]
        item.symbol.color = layers_colors[i]
    # Update
    polygons_lyr.symbology = polygons_sym

    Die Symbolisierung wird aktualisiert. (Um diese besser erkennen zu können, müssen Sie die Karte möglicherweise vergrößern.)

    Karte mit aktualisierter Polygon-Symbolisierung

  10. Speichern Sie das Projekt.

Layer veröffentlichen

Als Nächstes veröffentlichen Sie die Layer in ArcGIS Online oder einem ArcGIS Enterprise-Portal.

  1. Überprüfen Sie, ob Sie bei einem ArcGIS Online-Konto (oder mit einem Named-User-Konto beim ArcGIS Enterprise-Portal) angemeldet sind.
    Hinweis:

    Wenn Sie angemeldet sind, wird der Name Ihres Kontos in der oberen rechten Ecke von ArcGIS Pro angezeigt.

  2. Klicken Sie auf dem Menüband auf die Registerkarte Freigeben. Klicken Sie in der Gruppe Freigeben als auf Web-Layer.

    Schaltfläche "Web-Layer" in der Gruppe "Freigeben als"

  3. Legen Sie im Bereich Als Web-Layer freigeben folgende Parameter fest:
    • Geben Sie unter Name den Text Coral Reef Watch ein.
    • Geben Sie unter Zusammenfassung den Text NOAA's latest data for risk of coral bleaching ein.
    • Geben Sie unter Tags die Begriffe NOAA, Coral Bleaching und Alert Levels ein, wobei Sie zwischen den Tags jeweils die Eingabetaste drücken.
    • Als Layer-Typ muss Feature ausgewählt sein.

    Elementdetails und die Parameter für den Layer-Typ

  4. Klicken Sie auf Analysieren.

    Der Layer wird analysiert, um sicherzustellen, dass keine Fehler vorhanden sind, die die Veröffentlichung verhindern würden. Die Analyse gibt keine Fehler zurück, aber einige Warnungen in Bezug auf die Feature-Vorlage und die Datenquelle. Im Rahmen dieser Übung können Sie diese Warnungen ignorieren.

  5. Klicken Sie auf Veröffentlichen.

    Das Werkzeug wird ausgeführt. Im unteren Bereich wird eine Meldung angezeigt, die bestätigt, dass der Web-Layer veröffentlicht wurde.

  6. Speichern Sie das Projekt.

    Als Nächstes vergewissern Sie sich, dass der Layer erfolgreich veröffentlicht wurde, indem Sie ihn einer Webkarte hinzufügen.

  7. Melden Sie sich bei Ihrem ArcGIS-Organisationskonto oder beim ArcGIS Enterprise-Portal an.
  8. Klicken Sie auf dem Menüband auf Inhalt.

    Option "Inhalt" auf dem Menüband

    Der Seite Inhalt wurden zwei neue Elemente hinzugefügt: der Feature-Layer "Coral Reef Watch" und die Service-Definition.

  9. Klicken Sie für den Feature-Layer Coral Reef Watch auf die Schaltfläche "Optionen" (die drei horizontalen Punkte), und wählen Sie In Map Viewer öffnen aus.

    Option "In Map Viewer öffnen"

    Eine Webkarte mit den von Ihnen erstellten Layern wird geöffnet.

In dieser Lektion haben Sie mit Python die aktuellen Daten aus dem Coral Reef Watch Program abgerufen, diese in zwei Feature-Classes konvertiert und symbolisiert. Anschließend haben Sie die Layer als Feature-Service veröffentlicht. In der nächsten Lektion entwickeln Sie eine Feed-Routine, um automatisch die aktuellen Coral Reef Watch-Daten herunterzuladen, sobald diese verfügbar sind.


Eine Feed-Routine erstellen

In der vorherigen Lektion haben Sie die aktuellen Daten aus dem Coral Reef Watch Program der NOAA abgerufen, kartiert und veröffentlicht. Diese Daten zeigen Informationen zur Korallenbleiche zu einem bestimmten Zeitpunkt an, aber sie werden häufig aktualisiert. Wie können Sie Ihre Karte immer dann aktualisieren, wenn die NOAA ihre Daten aktualisiert?

In dieser Lektion entwickeln Sie eine Feed-Routine. Feed-Routinen laden Inhalte automatisch herunter, verarbeiten sie und veröffentlichen ein Dataset. Ihre Feed-Routine beinhaltet den Python-Workflow, den Sie in der vorherigen Lektion verwendet haben.

Eigenständiges Skript erstellen

Anstatt Ihr Skript, wie in der vorherigen Lektion, in ArcGIS Pro auszuführen, erstellen Sie in einem Texteditor ein eigenständiges Skript, das sich mit einem einzigen Befehl speichern und ausführen lässt. Dieses Skript enthält Ihre Feed-Routine und folgt den Richtlinien der ALF-Methode (Aggregated Live Feed).

Die ALF-Methode umfasst eine Reihe von Richtlinien, Werkzeugen und Funktionen, die bei der Bereitstellung einer Live-Feed-Routine in einer Produktionsumgebung eingesetzt werden. Die Werkzeuge ermöglichen die Automatisierung der Bereitstellung der Routine mit minimaler Überwachung. Die ALF-Methode umfasst die Schritte einer Live-Feed-Routine und ergänzt sie um Komponenten, die den allgemeinen Workflow verbessern. Diese Komponenten fügen Funktionen hinzu, um alle ausgeführten Schritte in einem Protokoll aufzuzeichnen, Dateien effizient zu entzippen und automatisch E-Mails zu versenden, wenn etwas nicht funktioniert.

Hinweis:

Um mehr über die ALF-Methode zu erfahren, können Sie derAggregated Live Feed Community beitreten. Außerdem können Sie das Dokument Aggregated Live Feed Methodologies herunterladen und lesen.

  1. Öffnen Sie in einem Texteditor eine neue Datei.
    Hinweis:

    Falls Sie keinen Texteditor besitzen, können Sie Notepad++ kostenlos herunterladen. Sie können auch Python-IDEs (Integrated Development Environments) wie PyCharm, PyScripter oder Spyder verwenden. In den Beispielabbildungen dieser Lektion wird Notepad++ verwendet.

    Als Erstes speichern Sie die Datei als Python-Skriptdatei. Einige Texteditoren, darunter Notepad++, heben je nach verwendeter Programmiersprache die Syntax hervor, was beim Schreiben von Code hilfreich sein kann.

  2. Klicken Sie auf dem Menüband auf File, und wählen Sie Save oder Save As aus. Speichern Sie die Datei als coral_reef_exercise.py an einem Speicherort Ihrer Wahl.
    Hinweis:

    Wie die Datei als Python-Datei (.py) gespeichert wird, kann je nach verwendetem Programm unterschiedlich sein.

    Beim Kartieren der aktuellen Daten in der vorherigen Lektion haben Sie als Erstes das Modul sys importiert, d. h. Sie müssen am Anfang Ihrer Feed-Routine eine entsprechende Anweisung hinzufügen.

  3. Erstellen Sie im Texteditor die Zeile import sys.

    Außerdem definieren Sie eine neue Funktion namens feedRoutine, die die Argumente url (die URL zu den Daten) und workGDB (den Pfad zu der bereits erstellten File-Geodatabase) erfordert. Später definieren Sie diese Funktion so, dass sie die Schritte zum Abrufen und Kartieren der Daten ausführt, aber zunächst verwenden Sie anstelle dieser Schritte den Platzhalterwert pass.

    Außerdem fügen Sie die Anweisung __name__ = "__main__" hinzu, die dafür sorgt, dass das Skript als eigenständige Routine ausgeführt werden kann (z. B. an der Eingabeaufforderung). In diesem Fall führt das eigenständige Skript die Funktion feedRoutine aus, indem es an der Eingabeaufforderung die Argumente url und workGDB über der Anweisung sys.argv[1:] an die Funktion weiterleitet.

  4. Drücken Sie zweimal die EINGABETASTE. Kopieren Sie die folgenden Zeilen, beginnend mit Zeile 3, und fügen Sie diese ein:
    def feedRoutine (url, workGDB):
        pass
    if __name__ == "__main__":
    	[url, workGDB] = sys.argv[1:]
    	feedRoutine (url, workGDB)
    Hinweis:

    Einrückungen sind wichtig, um sicherzustellen, dass das Skript korrekt ausgeführt wird. Achten Sie darauf, dass alle Einrückungen im Skript beibehalten werden. Fügen Sie keine unnötigen Einrückungen hinzu.

    Feed-Routine mit ersten Anweisungen

    Sie haben verschiedene andere Module während des Workflows importiert. Anstatt die Import-Anweisung für jedes Modul erneut auszuführen, lassen Sie das Skript alle erforderlichen Module mit derselben Funktion importieren.

  5. Ändern Sie Zeile 1 (import sys) in import sys, arcpy, os, tempfile, json. Drücken Sie die Eingabetaste, und geben Sie from urllib import request in Zeile 2 ein.

    Die vollständigen Zeilen sehen nun wie folgt aus:

    import sys, arcpy, os, tempfile, json
    from urllib import request

    Feed-Routine mit allen Modulen

    Als Nächstes beginnen Sie, den Platzhalter pass durch die erforderlichen Schritte zu ersetzen, um Daten abzurufen und Layer zu erstellen. Zuerst definieren Sie workGDB als Standard-Geodatabase (arpy.env.workspace) und erstellen die Geodatabase mithilfe der Funktion arcpy.management.CreateFileGDB.

  6. Ersetzen Sie Zeile 5 (pass) durch folgende Zeilen:
    # workGDB and default workspace
        arcpy.env.workspace = workGDB 
        arcpy.management.CreateFileGDB(os.path.dirname(workGDB), os.path.basename(workGDB))
    Hinweis:

    Abhängig von der Fenstergröße können einige der längeren Linien umgebrochen werden, wie in der folgenden Abbildung gezeigt.

    Feed-Routine mit definierter Standard-Geodatabase

    Als Nächstes fügen Sie Platzhaltercode für eine Bereitstellungslogik-Funktion hinzu. Sie benötigen diese Funktion zwar noch nicht, werden sie jedoch in späteren Lektionen verwenden, weshalb Sie dafür sorgen sollten, dass in Ihrem Skript Platz dafür zur Verfügung steht. Außerdem fügen Sie einen Platzhalter für den Code aus der vorherigen Lektion hinzu.

  7. Drücken Sie nach Zeile 7 zweimal die Eingabetaste, und entfernen Sie die Einrückungen. Kopieren Sie die folgenden Zeilen (einschließlich der Einrückungen), und fügen Sie sie ab Zeile 9 ein:
    ### Placeholder for retrieving and mapping data ###
        # Deployment Logic
        deployLogic()
        # Return
        return True
    def deployLogic():
        pass

    Feed-Routine mit Platzhaltern für Bereitstellungslogik

    Hinweis:

    Es ist wichtig, dass für die Einrückungen nicht Tabulatoren, sondern Leerzeichen verwendet werden.

    Als Nächstes ersetzen Sie den Platzhalter für das Abrufen und Kartieren der Daten durch den Code, den Sie in der vorherigen Lektion ausgeführt haben.

    Der Code zum Ändern der Symbolisierung ist in diesem Code nicht enthalten. Die Symbolisierung für die Layer ist sowohl in Ihrem ArcGIS Pro-Projekt als auch in der Webkarte gespeichert, sodass Sie die Symbolisierung nicht noch einmal ändern müssen. (Der Code zum Hinzufügen und Berechnen der alert_level-Felder wird beibehalten, da diese Felder für die vorhandene Symbolisierung benötigt werden.)

    Darüber hinaus enthält dieser Code mehrere print()-Funktionen mit Anweisungen, die Sie darüber informieren, welche Zeilen ausgeführt werden.

  8. Ersetzen Sie Zeile 9 (### Placeholder for retrieving and mapping data ###) durch folgende Zeilen:
    # Download and split json file
        print("Downloading data...")
        temp_dir = tempfile.mkdtemp()
        filename = os.path.join(temp_dir, 'latest_data.json')
        response = request.urlretrieve(url, filename)
        with open(filename) as json_file:
            data_raw = json.load(json_file)
            data_stations = dict(type=data_raw['type'], features=[])
            data_areas = dict(type=data_raw['type'], features=[])
        for feat in data_raw['features']:
            if feat['geometry']['type'] == 'Point':
                data_stations['features'].append(feat)
            else:
                data_areas['features'].append(feat)
        # Filenames of temp json files
        stations_json_path = os.path.join(temp_dir, 'points.json')
        areas_json_path = os.path.join(temp_dir, 'polygons.json')
        # Save dictionaries into json files
        with open(stations_json_path, 'w') as point_json_file:
            json.dump(data_stations, point_json_file, indent=4)
        with open(areas_json_path, 'w') as poly_json_file:
            json.dump(data_areas, poly_json_file, indent=4)
        # Convert json files to features
        print("Creating feature classes...")
        arcpy.conversion.JSONToFeatures(stations_json_path, 'alert_stations') 
        arcpy.conversion.JSONToFeatures(areas_json_path, 'alert_areas')
        # Add 'alert_level ' field
        arcpy.management.AddField('alert_stations', 'alert_level', 'SHORT', field_alias='Alert Level')
        arcpy.management.AddField('alert_areas', 'alert_level', 'SHORT', field_alias='Alert Level')
        # Calculate 'alert_level ' field
        arcpy.management.CalculateField('alert_stations', 'alert_level', "int(!alert!)")
        arcpy.management.CalculateField('alert_areas', 'alert_level', "int(!alert!)")

    Als Nächstes fügen Sie anderen Teilen des Skripts drei weitere print()-Funktionen hinzu, darunter eine, die Sie informiert, wenn das Skript abgeschlossen ist.

  9. Drücken Sie nach Zeile 5 (# workGDB and default workspace) die Eingabetaste. Löschen Sie in Zeile 6 alle vorhandenen Einrückungen, und erstellen Sie die folgende Zeile:
    print("Creating workGDB...")

    Feed-Routine, in der dem Block "workGDB" die Funktion "print()" hinzugefügt wurde

  10. Drücken Sie nach Zeile 43 (# Deployment Logic) die Eingabetaste. Löschen Sie in Zeile 44 alle vorhandenen Einrückungen, und erstellen Sie die folgende Zeile:
    print("Deploying...")
  11. Drücken Sie nach Zeile 47 (# Return) die Eingabetaste. Löschen Sie in Zeile 48 alle vorhandenen Einrückungen, und erstellen Sie die folgende Zeile:
    print("Done!")

    Abhängig davon, wie das Skript erstellt wurde, enthält es möglicherweise noch Tabulator-Einrückungen.

  12. Überprüfen Sie das gesamte Skript, um sicherzustellen, dass alle Einrückungen mit Leerzeichen und nicht mit Tabulatoren erzeugt wurden.
    Tipp:

    In Notepad++ können Sie Tabulatoren automatisch in Leerzeichen konvertieren. Klicken Sie auf dem Menüband auf Edit, zeigen Sie auf Blank Operations, und wählen Sie TAB to Space aus.

  13. Speichern Sie das Skript.
    Hinweis:

    Wenn Sie prüfen möchten, ob das Skript ordnungsgemäß erstellt wurde, können Sie es mit einem Beispielskript vergleichen.

    Als Nächstes testen Sie das Skript.

  14. Öffnen Sie das Windows-Startmenü. Suchen und öffnen Sie die Python-Eingabeaufforderung.

    Navigieren Sie zunächst zu dem Verzeichnis, in dem Sie die Datei coral_reef_exercise.py gespeichert haben.

    Hinweis:

    In den Beispielabbildungen wurde die Datei "coral_reef_exercise.py" im Ordner "Dokumente" gespeichert (C:\Users\Documents). Sie können den Pfad zu Ihrer Datei ermitteln, indem Sie in einem Dateibrowser wie Windows Explorer darauf zugreifen und den oben im Browser angezeigten Pfad kopieren.

  15. Geben Sie an der Python-Eingabeaufforderung cd ein, und drücken Sie die Leertaste. Fügen Sie den Pfad zu dem Verzeichnis ein, in dem Sie die Python-Datei gespeichert haben. Enthält der Pfad Leerzeichen, setzen Sie ihn in Anführungszeichen.

    Python-Eingabeaufforderung mit dem Befehl zum Ändern des Verzeichnisses

  16. Drücken Sie die Eingabetaste.

    Das Verzeichnis wird geändert. Führen Sie nun das Skript aus. Hierzu verwenden Sie den Befehl python und geben den Namen der Datei, die URL der Website mit den Daten zu Korallenriffen sowie den Pfad und den Namen der Geodatabase an.

  17. Führen Sie den folgenden Befehl aus:

    python coral_reef_exercise.py https://coralreefwatch.noaa.gov/vs/vs_polygons.json C:\Temp\Work.gdb

    Die Ausführung des Befehls dauert einige Sekunden. Während der Ausführung werden Sie durch die print()-Funktionen über den Fortschritt informiert.

    Python-Eingabeaufforderung mit eigenständigem Skript

    Die Layer in der Work-Geodatabase werden mit den neuesten Daten aktualisiert (wahrscheinlich handelt es sich dabei um die gleichen Daten, die Sie in der vorherigen Lektion verwendet haben). Das Skript aktualisiert die Layer, die auf der Karte in Ihrem ArcGIS Pro-Projekt oder auf Ihrer Webkarte angezeigt werden, zunächst nicht. Diese Funktionalität wird später mithilfe der deployLogic()-Funktion hinzugefügt.

Erweiterte Skriptfunktionalität hinzufügen

Ihr Skript funktioniert, aber es gibt noch Verbesserungspotenzial. Als Erstes passen Sie das Skript so an, dass eine Geodatabase nur dann erstellt wird, wenn noch keine vorhanden ist.

Sie erstellen eine if-Anweisung mithilfe der arcpy.Exists-Funktion, um zu überprüfen, ob der Workspace vorhanden ist. Ist dies der Fall, löschen Sie alle vorhandenen Feature-Classes, die mit alert_ beginnen, sodass sie durch neue Feature-Classes ersetzt werden können. Sie können beide Alert-Layer mit der Zeichenfolge alert_* darstellen, wobei das Sternchen für einen beliebigen Text steht.

  1. Öffnen Sie bei Bedarf das Skript coral_reef_exercise in einem Texteditor.
  2. Ersetzen Sie die Zeilen 5 bis 8 (die Zeilen für die Erstellung des Standard-Workspace) durch die folgenden Zeilen:
    # Create workGDB and default workspace
        print("Starting workGDB...")
        arcpy.env.workspace = workGDB
        if arcpy.Exists(arcpy.env.workspace):
            for feat in arcpy.ListFeatureClasses ("alert_*"):   
                arcpy.management.Delete(feat)
        else:
            arcpy.management.CreateFileGDB(os.path.dirname(workGDB), os.path.basename(workGDB))

    Erweitertes Skript zur Überprüfung auf vorhandene workGDB

    Wird das Skript auf einem Computer ohne Internetzugriff ausgeführt, kann die Online-JSON-Datei nicht heruntergeladen werden. Um diesen häufig auftretenden Fehler abzufangen, lösen Sie die Standardausnahme URLError aus, die den Benutzer darüber informiert, dass die URL nicht verfügbar ist.

  3. Ersetzen Sie Zeile 18 (response = request.urlretrieve(url, filename)) durch folgende Zeilen:
    try:
            response = request.urlretrieve(url, filename)
        except URLError:
            raise Exception("{0} not available. Check internet connection or url address".format(url))

    Erweitertes Skript zum Auslösen von URLError

    Als Nächstes zeichnen Sie die Ausführungsschritte in einer Protokolldatei auf. Da Sie bereits Meldungen zu jedem Teil des Skripts in der Eingabeaufforderung drucken, fügen Sie nach jeder print()-Funktion eine logging.info()-Funktion hinzu. Diese Funktion protokolliert Meldungen, die für das Debugging von Skriptfehlern nützlich sein können. Die protokollierten Meldungen enthalten auch das Datum und die Uhrzeit der Protokollierung.

    Zuerst ändern Sie Ihr Skript, um die Module logging und datetime zu importieren. Außerdem importieren Sie die zuvor verwendete Ausnahme URLError.

  4. Ersetzen Sie die Zeilen 1 und 2 (die Importzeilen) durch die folgenden Zeilen:
    import sys, os, tempfile, json, logging, arcpy
    import datetime as dt
    from urllib import request
    from urllib.error import URLError

    Als Nächstes konfigurieren Sie mithilfe der logging.basicConfig()-Funktion die Protokolldatei, in der die Meldungen protokolliert werden sollen. Außerdem legen Sie eine log_format-Variable fest, die definiert, wie das Datum und die Uhrzeit angezeigt werden.

  5. Fügen Sie nach Zeile 6 (def feedRoutine) die folgenden Zeilen hinzu:
    # Log file
        logging.basicConfig(filename="coral_reef_exercise.log", level=logging.INFO)
        log_format = "%Y-%m-%d %H:%M:%S"

    Erweitertes Skript zum Konfigurieren des Protokolls

    Als Nächstes fügen Sie logging.info()-Funktionen hinzu, die Meldungen zum Protokoll hinzufügen. Diese Funktionen zeichnen Datum und Uhrzeit mit der dt.datetime.now()-Funktion auf und formatieren Datum und Uhrzeit mit der zuvor erstellten log_format-Variablen. Sie fügen diese Funktionen nach jeder print()-Funktion hinzu.

  6. Fügen Sie nach Zeile 11 (print("Starting workGDB...")) die folgenden Zeile hinzu:
    logging.info("Starting workGDB... {0}".format(dt.datetime.now().strftime(log_format)))
  7. Fügen Sie nach Zeile 21 (print("Downloading data...")) die folgenden Zeile hinzu:
    logging.info("Downloading data... {0}".format(dt.datetime.now().strftime(log_format)))
  8. Fügen Sie nach Zeile 47 (print("Creating feature classes...")) die folgenden Zeile hinzu:
    logging.info("Creating feature classes... {0}".format(dt.datetime.now().strftime(log_format)))
  9. Fügen Sie nach Zeile 59 (print("Deploying...")) die folgenden Zeile hinzu:
    logging.info("Deploying... {0}".format(dt.datetime.now().strftime(log_format)))
  10. Fügen Sie nach Zeile 64 (print("Done!")) die folgenden Zeile hinzu:
    logging.info("Done! {0}".format(dt.datetime.now().strftime(log_format)))

    Außerdem protokollieren Sie die Ausnahme URLError mithilfe der Funktion logging.exception().

  11. Fügen Sie nach Zeile 27 (except URLError) die folgenden Zeilen hinzu:
    logging.exception("Failed on: request.urlretrieve(url, filename) {0}".format(
                              dt.datetime.now().strftime(log_format)))

    Als Letztes schließen Sie die Protokolldatei am Ende des Skripts mit der Funktion logging.shutdown().

  12. Drücken Sie am Ende von Zeile 63 zweimal die Eingabetaste, und entfernen Sie die Einrückungen in den neuen Zeilen. Fügen Sie in Zeile 65 die folgenden Zeilen hinzu:
    # Close Log File
        logging.shutdown()

    Erweitertes Skript zum Schließen der Protokolldatei

  13. Ihr Skript darf keine Tabulator-Einrückungen enthalten. Speichern Sie das Skript.
    Hinweis:

    Wenn Sie prüfen möchten, ob das Skript ordnungsgemäß erstellt wurde, können Sie es mit einem Beispielskript vergleichen.

In dieser Lektion haben Sie eine Feed-Routine erstellt, die als eigenständiges Skript an der Eingabeaufforderung ausgeführt werden kann. Außerdem haben Sie einige erweiterte Funktionen hinzugefügt. In der nächsten Lektion passen Sie die Feed-Routine an, um die Feature-Classes in Ihrem ArcGIS Pro-Projekt zu aktualisieren.


Lokale Feature-Classes aktualisieren

In der vorherigen Lektion haben Sie eine Feed-Routine erstellt. Wenn Sie diese ausführen, werden die jeweils aktuellen Daten der NOAA zur Korallenbleiche heruntergeladen, und es werden zwei Feature-Classes erstellt: eine für Punkt- und eine für Polygondaten. Diese Feature-Classes befinden sich in der Work-Geodatabase. Die Layer im ArcGIS Pro-Projekt, die sich in der Live-Geodatabase befinden, werden durch das Skript allerdings nicht aktualisiert.

In dieser Lektion werden Sie Ihre Feed-Routine so anpassen, dass die alert_stations- und alert_areas-Layer Ihres ArcGIS Pro-Projekts automatisch aktualisiert werden.

Die Funktion für die Bereitstellungslogik definieren

Ihre Feed-Routine enthält ein Platzhalterskript für eine Funktion mit dem Namen deployLogic() für die Bereitstellungslogik. In der ALF-Methodik ist der Prozess der Bereitstellungslogik der Teil der Feed-Routine, der die Live-Daten (die Feature-Classes in der Live-Geodatabase) mit den aktuellen Informationen aus dem Internet (in Ihrem Fall die Daten in der Work-Geodatabase) überschreibt.

  1. Erstellen Sie eine Kopie Ihres coral_reef_exercise.py-Skripts mit dem Namen coral_reef_exercise_local.py. Öffnen Sie die Kopie in einem Texteditor oder in Python IDE.

    Ändern Sie das Skript so, dass das shutil-Modul importiert wird. Dieses Modul enthält verschiedene erweiterte Dateioperationen, die für die Definition der Funktion für die Bereitstellungslogik erforderlich sind.

  2. Fügen Sie in Zeile 1 des coral_reef_exercise_local.py-Skripts shutil zur Liste der Module hinzu.

    Importfunktion mit Shutil-Modul

    Als Nächstes fügen Sie ein drittes Argument namens liveGDB zur Feed-Routine hinzu. Dieses steht für die Live-Geodatabase, in der sich die Layer Ihres Projekts befinden.

  3. Fügen Sie in Zeile 6 liveGDB zur Liste der feedRoutine-Argumente hinzu.

    Feed-Routine mit liveGDB-Argument

    Fügen Sie dieses Argument ebenfalls zum sys.argv[1:]-Befehl am Ende des Skripts hinzu. So können Benutzer den Pfad und den Namen der Live-Geodatabase bereitstellen, wenn sie das Skript über die Eingabeaufforderung ausführen.

  4. Fügen Sie in Zeile 77 liveGDB in die eckigen Klammern ein. Fügen Sie in Zeile 78 liveGDB zur Liste der feedRoutine-Argumente hinzu.

    Feed-Routine mit zusätzlichen liveGDB-Argumenten

    Die deployLogic()-Funktion verwendet die beiden Argumente workGDB und liveGDB; fügen Sie diese also an der Position ein, an der die Funktion aufgerufen und definiert wird.

  5. Ersetzen Sie in Zeile 63 und 73 deployLogic() durch deployLogic(workGDB, liveGDB).

    Feed-Routine mit deployLogic()-Argumenten

    Als Nächstes definieren Sie die deployLogic()-Funktion. Kopieren Sie mit einer for-Schleife alle Elemente im workGDB-Argument, und ersetzen Sie die Elemente im liveGDB-Argument. Listen Sie die Dateien mit der os.walk()-Funktion auf, und kopieren und ersetzen Sie sie mit der shutil.copy2()-Funktion. Gemäß der ALF-Methodik werden alle .lock-Dateien vom Skript ignoriert.

  6. Ersetzen Sie in Zeile 74 das Platzhalterskript pass durch folgende Zeilen:
    for root, dirs, files in os.walk(workGDB, topdown=False):
    	    files = [f for f in files if '.lock' not in f]
    	    for f in files:
    	        shutil.copy2(os.path.join(workGDB, f), os.path.join(liveGDB, f))

    Skript zur Definition der deployLogic()-Funktion

    Hinweis:

    Durch diese Feed-Routine werden die Feature-Classes in Ihrem ArcGIS Pro-Projekt automatisch ersetzt. Beachten Sie hierbei aber die unbedingt folgenden Hinweise: Die neuen Feature-Classes müssen mit der alten Datenstruktur übereinstimmen; fehlende Felder oder unterschiedliche Namen können das Kartenprojekt beschädigen.

  7. Ihr Skript darf keine Tabulator-Einrückungen enthalten. Speichern Sie das Skript.
    Hinweis:

    Wenn Sie prüfen möchten, ob das Skript ordnungsgemäß erstellt wurde, können Sie es mit einem Beispielskript vergleichen.

Das eigenständige Skript ausführen

Als Nächstes führen Sie die angepasste Feed-Routine aus und aktualisieren Ihr ArcGIS Pro-Projekt.

Wahrscheinlich wurden die Daten, die Sie zuletzt in Ihr Projekt eingebunden haben, noch nicht durch die NOAA aktualisiert. Wenn Sie das Skript also jetzt ausführen, sehen Sie möglicherweise keine Änderungen. Wenn Sie Ihre Skriptfunktionen testen möchten, sollten Sie Ihre Daten durch eine historische Datei austauschen, die von Learn ArcGIS gehostet wird.

  1. Öffnen Sie bei Bedarf Ihr Projekt Coral Bleaching in ArcGIS Pro.
  2. Öffnen Sie ggf. die Python-Eingabeaufforderung, und rufen Sie mit dem cd-Befehl das Verzeichnis mit der Datei "coral_reef_exercise_local.py" auf.
  3. Führen Sie über die Eingabeaufforderung folgenden Befehl aus:

    python coral_reef_exercise_local.py https://downloads.esri.com/LearnArcGIS/update-real-time-data-with-python/vs_polygons.json C:\Temp\Work.gdb C:\Temp\Live.gdb

    Der Befehl wird ausgeführt.

    Python-Eingabeaufforderung mit dem ausgeführtem Befehl

    Hinweis:

    Wenn die Daten durch das NOAA Coral Reef Watch Programm aktualisiert werden, können Sie die URL, die auf die historische Datei verweist (https://downloads.esri.com/LearnArcGIS/update-real-time-data-with-python/vs_polygons.json), durch die URL zu den Daten von NOAA (https://coralreefwatch.noaa.gov/vs/vs_polygons.json) ersetzen.

    Die erfolgreiche Ausführung des Befehls wird zwar bestätigt, allerdings ist die Karte in ArcGIS Pro unverändert. Starten Sie ArcGIS Pro neu, und aktualisieren Sie die Kartenanzeige, um die Änderungen sichtbar zu machen.

  4. Schließen Sie ArcGIS Pro (und speichern Sie Ihre Arbeit, wenn Sie dazu aufgefordert werden). Öffnen Sie Ihr Projekt Coral Bleaching erneut.

    Durch den Neustart von ArcGIS Pro wurde möglicherweise auch die Kartenanzeige aktualisiert. Falls nicht, können Sie die Anzeige manuell aktualisieren.

  5. Klicken Sie ggf. rechts unten in der Kartenansicht auf die Schaltfläche Aktualisieren.

    Schaltfläche "Aktualisieren"

    Die Karte wird mit den historischen Daten (vom 19. Februar 2019) aktualisiert.

    Karte mit historischen Daten

    Sie können auch nachprüfen, ob die Attributdaten aktualisiert wurden.

  6. Klicken Sie auf der Karte auf ein beliebiges Stations- oder Flächen-Feature.

    Das Pop-up des Features wird geöffnet. Der Wert im Datumsfeld lautet 2019-02-19; das ist das Datum der historischen Daten.

    Pop-up mit historischen Daten

  7. Schließen Sie das Pop-up.

In dieser Lektion haben Sie eine Feed-Routine zur Aktualisierung eines lokalen Datasets entwickelt und ausgeführt. Sie haben die Feed-Routine getestet, indem Sie die Karte mit historischen Daten aktualisiert haben; wenn Sie die im Python-Befehl verwendete URL ersetzen, können Sie denselben Prozess aber auch für die aktuellen Daten der NOAA ausführen. In der nächsten Lektion werden Sie eine ähnliche Feed-Routine entwickeln und ausführen, um einen Online-Feature-Service zu aktualisieren.


Einen Online-Feature-Service aktualisieren

In der vorherigen Lektion haben Sie eine Feed-Routine entwickelt und ausgeführt, um lokale Feature-Classes in Ihrem ArcGIS Pro-Projekt zu aktualisieren. In dieser Lektion werden Sie mit einem ähnlichen Prozess eine Feed-Routine für die Aktualisierung eines Online-Feature-Service in einer Webkarte entwickeln und ausführen.

Die Service-Definition und die ID ermitteln

Sie haben bei der Aktualisierung einer lokalen Feature-Class die neuen Daten in die Live-Geodatabase kopiert. Da Online-Feature-Services nicht in Geodatabases gespeichert werden, benötigen Sie stattdessen die Service-Definitionsdatei und die Element-ID, um den Feature-Service mithilfe von ArcGIS API for Python abzufragen und zu ersetzen.

In der ersten Lektion haben Sie einen Feature-Service mit den zuletzt verwendeten Daten veröffentlicht. Diesen verwenden Sie nun als Ziel für Aktualisierungen. Laden Sie als Erstes die Service-Definitionsdatei des Feature-Service herunter.

  1. Melden Sie sich ggf. bei Ihrem ArcGIS-Organisationskonto oder beim ArcGIS Enterprise-Portal an.
  2. Rufen Sie die Seite Inhalt und dann den Ordner mit dem Feature-Layer Coral Reef Watch und der Service-Definitionsdatei auf.
    Hinweis:

    Die Service-Definitionsdatei wurde bei der Veröffentlichung des Layers erstellt. Da Sie mit dieser Datei den Feature-Service aktualisieren, gehen eventuelle Änderungen, die nach der Veröffentlichung des Feature-Service vorgenommen wurden (z. B. an Metadaten oder der Symbolisierung) bei der Aktualisierung verloren. Das betrifft auch Webkarten oder Apps, die den Feature-Service enthalten.

    Am besten erstellen Sie einen Ansichts-Layer, um die Änderungen am Feature-Service beizubehalten. Karten oder Web-Apps, die den Feature-Layer verwenden, können anstatt auf den Feature-Service auf den Ansichts-Layer verweisen. Änderungen am Ansichts-Layer bleiben dann bei der Aktualisierung des Feature-Service erhalten. Öffnen Sie zur Erstellung eines Ansichts-Layers die Detailseite für den Feature-Layer, und klicken Sie auf Sicht-Layer erstellen. Weitere Informationen hierzu finden Sie auf der Seite mit der Dokumentation.

  3. Klicken Sie für die Service-Definitionsdatei Coral Reef Watch auf die Schaltfläche "Optionen" (drei Punkte), und wählen Sie Herunterladen aus.

    Service-Definitionsdatei herunterladen

    Die Service-Definitionsdatei (.sd) wird auf den Computer heruntergeladen.

  4. Kopieren Sie die Service-Definitionsdatei auf dem Laufwerk C: in den Ordner Temp.

    Kopieren Sie als Nächstes die Element-ID des Layers.

  5. Klicken Sie für den Feature-Layer Coral Reef Watch auf die Schaltfläche "Optionen" und dann auf Elementdetails anzeigen.

    Die Detailseite des Feature-Layers wird geöffnet. Die ID befindet sich in der URL.

  6. Kopieren Sie in der URL für die Detailseite die aus Ziffern und Buchstaben bestehende Zeichenfolge nach id= (im vorliegenden Beispiel lautet sie 2dcf249f5cd54a609d51acba6e0ba029).
    Hinweis:

    Die Element-ID Ihres Feature-Layers unterscheidet sich davon.

    Element-ID für Feature-Layer

  7. Fügen Sie die ID in eine leere Textdatei oder an eine andere leicht zugängliche Stelle ein.

Die Funktion für die Bereitstellungslogik definieren

Fertigen Sie dann eine weitere Kopie der ursprünglichen Feed-Routine an. Im Anschluss daran definieren Sie anhand eines Skripts, das einen Online-Feature-Service durch die aus der Work-Geodatabase herunterladen Daten ersetzt, die deployLogic()-Funktion.

  1. Erstellen Sie eine Kopie Ihres ursprünglichen coral_reef_exercise.py-Skripts mit dem Namen coral_reef_exercise_online.py. Öffnen Sie die Kopie in einem Texteditor oder in Python IDE.

    Sie benötigen für das erstellte Skript die Module fnmatch, shutil, subprocess und arcgis sowie das Submodul GIS.

  2. Fügen Sie in Zeile 1 des coral_reef_exercise_online.py-Skripts fnmatch, shutil, subprocess und arcgis zur Liste der Module hinzu. Drücken Sie die Eingabetaste, und fügen Sie from arcgis.gis import GIS in Zeile 2 ein.

    Die vollständigen Zeilen sehen nun wie folgt aus:

    import sys, os, tempfile, json, logging, arcpy, fnmatch, shutil, subprocess, arcgis
    from arcgis.gis import GIS

    Feed-Routine mit Zeilen zum Importieren von Modulen und Submodulen

    Als Sie die Funktion für die Bereitstellungslogik für die Aktualisierung einer lokalen Feature-Class definiert haben, haben Sie ein Argument namens liveGDB zur Feed-Routine hinzugefügt, das Sie für die Bereitstellung des Pfades zur erforderlichen Geodatabase bei Ausführung des Skripts verwenden konnten. Für diese Feed-Routine fügen Sie nun Parameter für die Element-ID des Feature-Service, die Service-Definitionsdatei und den Service-Namen hinzu.

  3. Fügen Sie in Zeile 7 die Argumente itemid, original_sd_file, und service_name zur Liste der feedRoutine-Argumente hinzu.

    Die vollständige Zeile sieht nun wie folgt aus:

    def feedRoutine (url, workGDB, itemid, original_sd_file, service_name):

    Zur feedRoutine-Funktion hinzugefügte Argumente

    Fügen Sie dann die folgenden Parameter zum sys.argv[1:]-Befehl am Ende des Skripts hinzu.

  4. Fügen Sie in Zeile 78 und 79 itemid, original_sd_file, und service_name zu beiden Argumentlisten hinzu.

    Die vollständigen Zeilen sehen nun wie folgt aus:

    [url, workGDB, itemid, original_sd_file, service_name] = sys.argv[1:]
        feedRoutine (url, workGDB, itemid, original_sd_file, service_name)

    Zum sys.argv[1:]-Befehl hinzugefügte Argumente

    Fügen Sie diese Argumente (und das Argument workGDB) auch zur deployLogic()-Funktion hinzu, wo sie definiert und aufgerufen wird.

  5. Ersetzen Sie in Zeile 64 und 74 deployLogic() durch deployLogic(workGDB, itemid, original_sd_file, service_name).

    Argumente für die deployLogic-Funktion, wo sie definiert und aufgerufen wird

    Als Nächstes definieren Sie die deployLogic()-Funktion. Diese Funktion führt verschiedene Aufgaben aus. Sie ruft das Feature-Service-Element mithilfe der gis.content.get()-Funktion aus ArcGIS Online oder dem ArcGIS Enterprise-Portal ab (dargestellt durch das itemid-Argument).

    Zudem erstellen Sie eine durch die GIS()-Funktion definierte gis-Variable. Die Argumente dieser Funktion enthalten die URL des Portals Ihrer Organisation (die URL für ArcGIS Online lautet https://arcgis.com), den Benutzernamen und das Kennwort für Ihr Konto.

  6. Ersetzen Sie in Zeile 75 das Platzhalterskript (pass) durch folgende Zeilen:
    # Get item from ArcGIS Online
        gis = GIS(url='https://arcgis.com', username='your_username', password='your_password')
        item = gis.content.get(itemid)
        sd_file_name = os.path.basename(original_sd_file)
        if sd_file_name != item.related_items("Service2Data")[0].name:
            raise Exception('Erroneous itemid, service name, or original sd file'.format(itemid))
    Hinweis:

    Wenn Sie mit einem ArcGIS Online-Konto arbeiten, ist der url-Parameter optional.

  7. Ersetzen Sie in Zeile 76 die Parameter username und password durch den Benutzernamen und das Kennwort für Ihr ArcGIS-Konto. Wenn es sich um ein Konto für ein ArcGIS Enterprise-Portal handelt, ersetzen Sie den Parameter url durch die Portal-URL.
    Vorsicht:

    Da dieses Skript Ihr Kennwort enthält, sollten Sie es nicht leichtfertig an andere Personen weitergeben. Es gibt eine erweiterte Skriptfunktionalität, mit der Sie Ihre Anmeldeinformationen schützen können.

    Als Nächstes entpackt die deployLogic()-Funktion den Inhalt der Service-Definitionsdatei (original_sd_file). Dafür wird das Programm 7-Zip verwendet, mit dem Windows-Computer häufig standardmäßig ausgestattet sind. Bevor Sie das Skript hinzufügen, das die Datei mithilfe von 7-Zip entpackt, müssen Sie sich vergewissern, dass sich das Programm auf Ihrem Computer befindet. Fügen Sie es dann in Windows zur Umgebungsvariablen Path hinzu. Wenn Sie das getan haben, können Sie das Programm mit Ihrem Skript aufrufen.

  8. Laden Sie ggf. die richtige Version von 7-Zip auf Ihren Computer herunter, und installieren Sie sie.

    Die Bearbeitung einer Umgebungsvariablen ist abhängig vom Betriebssystem. In der Regel erfolgt sie im Fenster Umgebungsvariablen.

  9. Öffnen Sie auf Ihrem Computer die Einstellungen. Klicken Sie auf System und Sicherheit, System und dann auf Erweiterte Systemeinstellungen. Klicken Sie im Fenster Systemeigenschaften auf Umgebungsvariablen. (Der genaue Pfad ist abhängig von Ihrem Betriebssystem.)
  10. Wählen Sie im Fenster Umgebungsvariablen unter Systemvariablen, die Variable Path aus, und klicken Sie auf Bearbeiten.

    Je nach Betriebssystem öffnet sich das Fenster Umgebungsvariable bearbeiten oder Systemvariable bearbeiten. Davon ist abhängig, wie die neuen Variablen hinzugefügt werden.

  11. Im Fenster Umgebungsvariable bearbeiten müssen Sie auf Neu klicken und als neue Variable C:\Program Files\7-Zip hinzufügen. Im Fenster Systemvariable bearbeiten scrollen Sie an das Ende des Parameters für den Variablenwert und fügen ;C:\Programme\7-Zip ein (achten Sie darauf, dass Sie vorhandenen Text nicht löschen).
  12. Klicken Sie auf "OK". Klicken Sie im Fenster Umgebungsvariablen auf OK.

    Erstellen Sie nun das Skript. Wenn 7-Zip in der Umgebungsvariablen Path nicht gefunden wird, enthält es eine Fehlermeldung.

  13. Fügen Sie nach Zeile 80 die folgenden Zeilen zum coral_reef_exercise_online.py-Skript hinzu:
    # Unpack original_sd_file using 7-zip
        path_7z = fnmatch.filter(os.environ['path'].split(';'), '*7-Zip')
        temp_dir = tempfile.mkdtemp()
        if len(path_7z):
            exe_7z = os.path.join(path_7z[0], '7z.exe')
            call_unzip = '{0} x {1} -o{2}'.format(exe_7z, original_sd_file, temp_dir)
        else:
            raise Exception('7-Zip could not be found in the PATH environment variable')
        subprocess.call(call_unzip)

    Wenn der Feature-Service in das Skript übernommen und die Service-Definitionsdatei entpackt wurde, ersetzen Sie ihre Daten durch die Daten, die Sie in die Geodatabase "Work.gdb" heruntergeladen haben. Als temporären Ordner hierfür, den Sie in eine neue Service-Definitionsdatei entpacken können, verwenden Sie die Geodatabase "Live.gdb".

    Ihr Skript löscht mithilfe der shutil.rmtree()-Funktion die Geodatabase "Live.gdb" und erstellt sie mit der os.mkdir()-Funktion erneut. Dabei werden vorhandene Inhalte aus der Geodatabase gelöscht.

  14. Fügen Sie nach Zeile 89 die folgenden Zeilen hinzu:
    # Replace Live.gdb content
        liveGDB = os.path.join(temp_dir, 'p20', 'live.gdb')
        shutil.rmtree(liveGDB)
        os.mkdir(liveGDB)
        for root, dirs, files in os.walk(workGDB):
            files = [f for f in files if '.lock' not in f]
            for f in files:
                shutil.copy2(os.path.join(workGDB, f), os.path.join(liveGDB, f))

    Als Nächstes wird die Geodatabase "Live.gdb" in eine neue Service-Definitionsdatei namens updated_sd gepackt.

  15. Fügen Sie nach Zeile 97 die folgenden Zeilen hinzu:
    # Zip file
        os.chdir(temp_dir)
        updated_sd = os.path.join(temp_dir, sd_file_name)
        call_zip = '{0} a {1} -m1=LZMA'.format(exe_7z, updated_sd)
        subprocess.call(call_zip)

    Abschließend überschreibt das Skript mithilfe der manager-Methode (arcgis.features.FeatureLayerCollection.fromitem(item).manager) des Elements den Feature-Service mit den neuen Daten.

  16. Fügen Sie nach Zeile 102 die folgenden Zeilen hinzu:
    # Replace file
        manager = arcgis.features.FeatureLayerCollection.fromitem(item).manager
        status = manager.overwrite(updated_sd)
        # Return
        return True
  17. Ihr Skript darf keine Tabulator-Einrückungen enthalten. Speichern Sie das Skript.
    Hinweis:

    Wenn Sie prüfen möchten, ob das Skript ordnungsgemäß erstellt wurde, können Sie es mit einem Beispielskript vergleichen.

Das eigenständige Skript ausführen

Führen Sie als Nächstes an der Python-Eingabeaufforderung die Feed-Routine aus, und aktualisieren Sie den Online-Feature-Service Coral Reef Watch. Ähnlich wie in der vorherigen Lektion werden Sie im Rahmen dieser Übung den Feature-Service mit historischen Daten aktualisieren.

  1. Öffnen Sie ggf. in ArcGIS Online oder Ihrem ArcGIS Enterprise-Portal den Feature-Layer Coral Reef Watch in Map Viewer.
  2. Öffnen Sie ggf. die Python-Eingabeaufforderung, und rufen Sie mit dem cd-Befehl das Verzeichnis mit der Datei "coral_reef_exercise_local.py" auf.
    Hinweis:

    Wenn Sie 7-Zip zur Umgebungsvariablen Path hinzugefügt haben, müssen Sie die Python-Eingabeaufforderung ggf. neu starten.

  3. Geben Sie folgenden Befehl ein (führen Sie ihn aber noch nicht aus):

    python coral_reef_exercise_online.py https://downloads.esri.com/LearnArcGIS/update-real-time-data-with-python/vs_polygons.json C:\Temp\Work.gdb

    Fügen Sie vor der Ausführung des Befehls die verbleibenden erforderlichen Argumente hinzu: die Element-ID, die ursprüngliche Service-Definitionsdatei und den Service-Namen.

  4. Drücken Sie am Ende des Befehls die Leertaste, und fügen Sie die Element-ID für den Feature-Service ein.
    Hinweis:

    Die Element-ID ist eine aus Buchstaben und Ziffern bestehende Zeichenfolge, die in der URL des Feature-Service zu finden ist, z. B. 2dcf249f5cd54a609d51acba6e0ba029.

    Sie haben zuvor die ursprüngliche Service-Definitionsdatei heruntergeladen und in den Ordner "Temp" kopiert. Der Service-Name lautet Coral_Reef_Watch.

  5. Drücken Sie die Leertaste, und fügen Sie C:\Temp\Coral_Reef_Watch.sd Coral_Reef_Watch ein.

    Das Format des vollständigen Befehl ähnelt dem folgenden (sie unterscheiden sich lediglich in der Element-ID):

    python coral_reef_exercise_online.py https://downloads.esri.com/LearnArcGIS/update-real-time-data-with-python/vs_polygons.json C:\Temp\Work.gdb 2dcf249f5cd54a609d51acba6e0ba029 C:\Temp\Coral_Reef_Watch.sd Coral_Reef_Watch

    Beispielbefehl in der Python-Eingabeaufforderung

  6. Führen Sie den Befehl aus.

    Der Befehl wird ausgeführt. An der Eingabeaufforderung werden viele Informationen über 7-Zip und die extrahierten Daten zurückgegeben. Wenn die Ausführung des Befehls abgeschlossen ist, wird an der Eingabeaufforderung die Zeile Done ausgegeben.

    Eingabeaufforderung mit Ausgabe "Done"

    Als Nächstes visualisieren Sie die Änderungen auf der Webkarte.

  7. Aktualisieren Sie die Webkarte mit der Schaltfläche Aktualisieren oder Erneut laden Ihres Browsers.

    Die Karte wurde mit Daten vom 19. Februar 2019 aktualisiert.

    Endgültige Karte mit Daten vom 19. Februar 2019

  8. Klicken Sie auf eine beliebige Station, um das entsprechende Pop-up zu öffnen.

    Der Eintrag im Datumsfeld lautet 2019-02-19; das bestätigt, dass die Daten ordnungsgemäß aktualisiert wurden.

    Datumsfeld im Pop-up

  9. Schließen Sie das Pop-up. Schließen Sie die Webkarte ohne vorheriges Speichern. (Auf Wunsch können Sie die Webkarte auch speichern.)

In dieser Lektion haben Sie Feed-Routinen für die automatische Aktualisierung von lokalen Layern und Web-Layern mit den neuesten NOAA-Daten erstellt. Die Lektion enthielt zudem eine Einführung in grundlegende und fortgeschrittene Python-Themen, und es wurde die ALF-Methode zur Entwicklung und Implementierung einer Feed-Routine angewendet. In dieser Lektion haben Sie die Layer mithilfe historischer Daten aktualisiert; dasselbe Skript kann aber auch mit der URL zu den NOAA-Daten ausgeführt werden.

Führen Sie das Skript regelmäßig aus, um Ihre Layer auf dem aktuellen Stand zu halten. Wenn Sie in Windows eine Aufgabe einrichten, wird das Skript in einem bestimmten Intervall automatisch ausführt, sodass die Daten in Echtzeit bereitgestellt werden.

Weitere Lektionen finden Sie in der Learn ArcGIS-Lektionsgalerie.