Representar cartográficamente los datos más recientes

Los corales dependen de las algas para sobrevivir. Unas temperaturas del océano demasiado elevadas o bajas reducen las algas, lo que blanquea los corales e incrementa las tasas de mortalidad. El programa Coral Reef Watch de la NOAA proporciona datos globales sobre el riesgo de decoloración de los corales. Estos datos se actualizan con frecuencia.

En esta lección, utilizará ArcGIS Pro y Python para recuperar los datos más recientes sobre la decoloración de los corales como un archivo JSON. A continuación, creará dos clases de entidad basadas en los datos, cambiará su simbología y las publicará. En lecciones posteriores, desarrollará una rutina de feed para que estas capas y servicios se actualicen automáticamente cuando haya nuevos datos disponibles.

Importar ArcPy y ArcGIS API for Python

Primero, creará un proyecto nuevo en ArcGIS Pro y cambiará su mapa base. A continuación, utilizará Python para importar ArcPy y ArcGIS API for Python.

ArcPy es un paquete de sitio de Python. Con él, puede utilizar Python para ejecutar herramientas de geoprocesamiento y otras funciones de ArcGIS. ArcGIS API for Python es una biblioteca de Python que también permite que Python realice tareas de SIG. Más tarde, la utilizará para conectarse a ArcGIS Online o ArcGIS Enterprise.

  1. Inicie ArcGIS Pro. Si se le pide, inicie sesión en su cuenta con licencia de ArcGIS (o portal de ArcGIS Enterprise con una cuenta de usuario nominal).
    Nota:

    Si no tiene ArcGIS Pro, puede registrarse para obtener una prueba gratuita de ArcGIS. Si inicia sesión en una cuenta de Enterprise, asegúrese de que ArcGIS Pro esté configurado para usar el portal de su organización.

  2. En Plantillas en blanco, haga clic en Mapa.

    Plantilla de mapa

  3. En la ventana Crear un nuevo proyecto, en Nombre, escriba Decoloración de corales. Haga clic en Aceptar.

    El proyecto de mapa vacío se abre en ArcGIS Pro. La extensión predeterminada puede variar en función de la configuración de su organización. En primer lugar, cambiará el mapa base a uno que resalte mejor los datos.

  4. En la cinta, haga clic en la pestaña Mapa. En el grupo Capa, haga clic en Mapa base y elija Lona gris claro.

    Opción de mapa base Lona gris claro

    El mapa base se agrega al mapa y al panel Contenido. El mapa base también contiene una capa de referencia que contiene topónimos. No necesitará esta capa de referencia, por lo que la desactivará.

  5. En el panel Contenido, desactive la capa Referencia gris claro mundial.

    Capa Referencia gris claro mundial desactivada en el panel Contenido

    A continuación, abrirá la ventana de Python.

    ArcGIS Pro incluye Python 3 a través de la distribución Anaconda. La distribución Anaconda incluye muchos módulos comunes de Python utilizados en aplicaciones de ciencia de datos.

  6. En la cinta, haga clic en la pestaña Análisis. En el grupo Geoprocesamiento, haga clic en Python.

    Botón Python de la pestaña Análisis

    Aparece la ventana de Python. La ventana tiene dos partes, la ventana de Python y la transcripción. En la ventana de Python se introduce el código de Python. La transcripción proporciona un registro del código de Python que ha introducido.

    Primero, ejecutará una línea simple de código de Python para familiarizarse con su sintaxis básica.

    Sugerencia:

    Puede cambiar la posición y el tamaño de la ventana de Python como desee. Arrastre la barra de título para cambiar la posición del panel y arrastre los bordes del panel para cambiar su tamaño. También puede acoplarla en varias áreas de ArcGIS Pro.

  7. Haga clic en la ventana de Python (donde dice Introducir código de Python aquí), escriba print('¡Hola, mundo!') y pulse Intro.

    Transcripción que contiene la función print

    La función print() provoca que la transcripción muestre el texto entre paréntesis. En este caso, print() es la función y 'Hello World!' el argumento (una variable o entrada para la función).

    Puede ejecutar muchas funciones de Python escribiendo el nombre de la función e incluyendo un argumento entre los paréntesis. Sin embargo, no todas las funciones de Python requieren un argumento, mientras que otras requieren varios argumentos (separados por comas).

    Las funciones devuelven un valor en la transcripción. Por otro lado, las sentencias ejecutan un proceso sin devolver un valor. Para importar módulo (por ejemplo, ArcPy), utilizará una sentencia, en lugar de una función. Primero, importará el módulo sys. Este módulo proporciona varias funciones específicas para su sistema.

  8. En la ventana de Python, escriba import sys y pulse Intro.

    Se importa el módulo sys. A continuación, utilizará el atributo version para mostrar su versión de Python. Los atributos son propiedades de objetos de Python (funciones, variable o constantes). Se pueden incorporar a objetos de Python utilizando un punto.

  9. Escriba sys.version y pulse Intro.

    Transcripción que contiene las líneas import sys y sys.version

    En este caso, la función sys es el objeto y version su atributo.

    La transcripción devuelve información sobre su versión de Python. En la imagen de ejemplo, la versión es 3.6.8. La versión puede diferir en función de su versión de ArcGIS Pro.

    Con ArcPy, puede ejecutar herramientas de geoprocesamiento de ArcGIS utilizando la ventana de Python. A continuación, importará el módulo arcpy de la misma forma que importó el módulo sys.

  10. En la ventana de Python, escriba import arcpy y pulse Intro.

    Se importa el módulo arcpy.

  11. Escriba help(arcpy) y pulse Intro.

    Transcripción que contiene las líneas import arcpy y help(arcpy)

    La función help() ofrece información sobre el argumento proporcionado (arcpy). En este caso, se agregó una gran cantidad de información. Quizá le interese cambiar el tamaño de la ventana de Python para echarle un vistazo a toda la información.

    A continuación, importará ArcGIS API for Python utilizando el módulo arcgis.

  12. En la ventana de Python, escriba import arcgis y pulse Intro.

    Se importa ArcGIS API for Python.

    Nota:

    Si recibe el mensaje ModuleNotFoundError al importar el módulo arcgis, puede que ArcGIS API for Python no se instale en su instancia de ArcGIS Pro. Para instalarlo, haga clic en la pestaña Proyecto y, después, en la pestaña Python. Haga clic en Agregar paquetes y busque arcgis. En la lista de resultados de búsqueda, haga clic en el paquete arcgis y, después, en Instalar. La guía Instalar y configurar explica con más detalle cómo instalar ArcGIS API for Python.

  13. Escriba help(arcgis) y pulse Intro.

    Transcripción que contiene las líneas import arcgis y help(arcgis)

    Se muestra la información sobre el módulo arcgis.

Descargar un archivo

A continuación, descargará datos espaciales en formato JSON del programa Coral Reef Watch de la NOAA. Estos datos contendrán la información más reciente sobre el riesgo de decoloración de los corales.

Los datos se alojan en el sitio web del Coral Reef Watch. Para recopilar los datos, utilizará varias funciones. Estas funciones requieren que primero se importen los módulos adecuados.

  1. Ejecute la siguiente línea en la ventana de Python:
    import os, tempfile

    Se importan los módulos os y tempfile. También se importará el submódulo request del módulo urllib.

  2. Ejecute la siguiente línea:
    from urllib import request

    El submódulo request incluye la función urlretrieve, que utilizará para recopilar los datos. La función urlretrieve requiere dos variables: la URL del archivo en línea (url) y la ubicación donde se guardará en su equipo (filename).

    En Python, las variables se definen y asignan utilizando un signo igual (=). Para definir la variable filename, ejecutará la función os.path.join() para unir un directorio temporal (temp_dir) al nombre previsto del archivo. Para definir el directorio temporal, ejecutará la función tempfile.mkdtemp().

    Nota:

    La variable filename puede ser cualquier ruta que apunte a una ubicación de su equipo. Sin embargo, se recomienda guardar el archivo en un directorio temporal. La función os.path.join() se utiliza porque funciona en todos los sistemas operativos, sin importar el carácter utilizado para separar carpetas en la ruta de archivo.

  3. Ejecute las siguientes líneas (cópielas y péguelas para ejecutarlas de una vez):
    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)
    Nota:

    Es posible que tenga que presionar Enter dos veces para ejecutar varias líneas de código que copie y pegue.

    Estas líneas definen todas las variables necesarias. Para comprobar la ruta del archivo JSON recuperado, ejecutará la función print con filename como el argumento.

  4. Ejecute la siguiente línea:
    print(filename)

    Transcripción que contiene la ruta a los datos más recientes

    En la imagen de ejemplo, la línea final es la ruta al archivo latest_data.json que ha recuperado (su ruta será diferente). Puede copiar el nombre de archivo y pegarlo en el explorador de archivos de su equipo (por ejemplo, el Explorador de Windows) para abrir el archivo. El archivo se puede abrir con cualquier editor de texto.

    A continuación, creará una variable data_raw para representar los datos en formato JSON. Utilizará esta variable siempre que haga referencia a datos JSON en una línea de código. Para crear la variable, deberá importar el módulo json para así poder ejecutar la función json.load(). También deberá crear una variable intermedia denominada json_file que abra su archivo.

  5. Ejecute las siguientes líneas:
    import json
    json_file = open(filename)
    data_raw = json.load(json_file)

    Aunque no ocurre nada en la transcripción, se abre la variable json_file (su archivo JSON) y con ella se carga la variable data_raw.

    Nota:

    La variable json_file permanecerá abierta hasta que se ejecute el comando json_file.close(). Otra forma de abrir el archivo es utilizando una sentencia with. Al hacerlo, se cerrará automáticamente el archivo después de cerrar el bloque de código. Las siguientes líneas de código representan la forma en que se puede abrir la variable json_file con una sentencia with:

    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.

    Las líneas que comienzan con signos numéricos (#) son comentarios que no afectan al código, pero proporcionan información para el usuario.

Crear capas a partir del archivo

Para visualizar los datos que ha descargado (y familiarizarse con la forma en que puede utilizar Python para interactuar con datos espaciales), creará dos clases de entidad basadas en el archivo JSON.

Primero, creará una geodatabase de archivos nueva para que contenga las clases de entidad. El archivo contiene datos para entidades poligonales y de puntos, por lo que lo separará en dos archivos JSON, uno para cada tipo de entidad. A continuación, creará una clase de entidad para cada archivo JSON y las guardará en la geodatabase.

Al igual que la función urlretrieve, la función para crear la geodatabase (arcpy.management.CreateFileGDB) requiere una ruta y un nombre. También ejecutará la función arcpy.env.workspace para definir la geodatabase como su espacio de trabajo predeterminado.

  1. En el Explorador de Windows, cree una carpeta denominada Temp en la unidad C de su equipo.
  2. Ejecute las siguientes líneas en la ventana de Python:
    arcpy.management.CreateFileGDB(r'C:\Temp', 'Live.gdb')
    arcpy.env.workspace = os.path.join(r'C:\Temp', 'Live.gdb')

    La geodatabase Live se crea en la carpeta Temp (puede abrir la carpeta para comprobarlo). A continuación, creará dos diccionarios, uno para entidades de puntos (estaciones) y uno para entidades poligonales (área de interés determinadas por la NOAA).

    En Python, los diccionarios son colecciones de elementos indexados y desordenados. Los diccionarios que usted crea tendrán dos elementos, tal y como requiere el formato de archivo GeoJSON. El elemento type hará referencia al tipo de geometría de la variable data_raw (su JSON). El elemento features enumerará las entidades. Por ahora, la lista estará vacía, como indica el par de corchetes.

  3. Ejecute las siguientes líneas:
    data_stations = dict(type=data_raw['type'], features=[])
    data_areas = dict(type=data_raw['type'], features=[])

    Transcripción que contiene líneas para crear diccionarios

    Se crean los diccionarios. A continuación, cargará las entidades de la variable data_raw en la biblioteca data_stations o data_areas, dependiendo del tipo de geometría de la entidad.

    Primero, creará un bucle for. Un bucle for ejecuta una función o sentencia para cada elemento de una lista. Creará uno que enlace todas las entidades de la variable data_raw. Al crear una sentencia if condicional, determinará el tipo de geometría de cada entidad. Luego, utilizando el método append(), incorporará entidades de tipos de geometría específicos a la lista de entidades de la biblioteca adecuada.

  4. Ejecute las siguientes líneas:
    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)
    Precaución:

    La Python Software Foundation recomienda utilizar espacios en lugar de tabulaciones para sangrar las líneas de código. No mezcle tabulaciones y espacios para la sangría, o el código no se ejecutará correctamente.

    Para cada entidad enumerada en los datos JSON, si el tipo de geometría es de puntos, la entidad se incorporará a la biblioteca data_stations. Si el tipo de geometría es poligonal o multipoligonal, la entidad se incorporará a la biblioteca data_areas.

    Ejecutará la función len() utilizando la lista data_stations['features'] para comprobar la cantidad de entidades que se han cargado a la lista.

  5. Ejecute la siguiente línea:
    len(data_stations['features'])

    Transcripción que muestra la función len() para contar las estaciones

    La línea devuelve el número 213, que indica que hay 213 entidades de puntos. Las entidades poligonales del JSON corresponden a las áreas de interés que determina la NOAA. Estas áreas cambian periódicamente, por lo que no es posible validarlas con tanta facilidad como las estaciones.

    En su lugar, accederá al nombre y las coordenadas de la décima entidad de la lista. En Python, las listas comienzan por 0 en lugar de 1, por lo que la décima entidad es la entidad 9.

  6. Ejecute la siguiente línea:
    data_areas['features'][9]['properties']['name']

    La transcripción devuelve el nombre de la décima entidad.

  7. Ejecute la siguiente línea:
    data_areas['features'][9]['geometry']['coordinates']

    La transcripción devuelve una larga lista de coordenadas, que corresponden a cada uno de los vértices del polígono.

    Nota:

    Dado que estos datos se actualizan periódicamente, sus resultados pueden diferir de los de la imagen de ejemplo.

    Transcripción que muestra el nombre y las coordenadas de la entidad Beagle Gulf

    A continuación, guardará los diccionarios como archivos JSON en el mismo directorio temporal donde guardó el JSON original (temp_dir). Ejecutará la función os.path.join() para crear rutas de archivo para cada JSON nuevo. Luego, creará sentencias with y utilizará la función json.dump() para guardar los diccionarios como archivos JSON.

  8. Ejecute las siguientes líneas (los comentarios son opcionales):
    # 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)

    Ejecutará la función print() en cada ruta para comprobar que los archivos se han guardado correctamente.

  9. Ejecute la siguiente línea:
    print(stations_json_path)
  10. Ejecute la siguiente línea:
    print(areas_json_path)
    Nota:

    Su ruta de archivo diferirá de las mostradas en la imagen de ejemplo.

    Transcripción con funciones print() para cada archivo JSON

    Cada ruta va a su carpeta Temp. Los nombres de archivo son points.json y polygons.json, tal y como ha especificado cuando ha ejecutado la función os.path.join(). Si lo desea, puede copiar cada ruta y abrir los archivos en un editor de texto.

    Ahora que se han creado los archivos JSON, ejecutará la función arcpy.conversion.JSONToFeatures() para convertirlos en clases de entidad. Esta función requiere la ruta al archivo JSON y el nombre de la clase de entidad que se va a crear.

  11. Ejecute las siguientes líneas:
    # Convert JSON files to features
    arcpy.conversion.JSONToFeatures(stations_json_path, 'alert_stations') 
    arcpy.conversion.JSONToFeatures(areas_json_path, 'alert_areas')

    Las clases de entidad se guardan en la geodatabase Live que definió como espacio de trabajo predeterminado. Se agregan dos capas, alert_stations y alert_areas, al mapa.

    Mapa que muestra estaciones y áreas

Cambiar la simbología

También puede actualizar la simbología de la capa con Python. Aunque no se requiere para crear una rutina de feed, es la mejor práctica para mostrar datos de forma significativa y atractiva. Además, el código que crea para cambiar la simbología se puede ajustar rápidamente si decide cambiarla más tarde.

Simbolizará las capas en función del nivel de alerta, que va de 0 a 4 dependiendo del estrés por calor registrado. Los niveles con menor alerta aparecerán en azul, mientras que los niveles con mayor alerta aparecerán en rojo. Las capas contienen campos de texto para el nivel de alerta, pero los campos deben ser numéricos para poder otorgarles una simbología graduada.

Primero, creará un campo numérico nuevo para el nivel de alerta utilizando la función arcpy.management.AddField. Para el argumento de esta función, primero enumere la capa a la que desea agregar el campo, luego, el nombre del campo y, por último, el tipo de datos y alias de campo. También puede especificar otros ajustes, pero estos son los únicos que necesita para estos campos.

  1. Ejecute las siguientes líneas en la ventana de Python:
    # 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')

    Las capas alert_stations y alert_areas tiene agregado un campo alert_level. Ambos campos tienen un tipo de datos de entero corto (un tipo de datos numéricos) y un alias de Alert Level.

    A continuación, calculará los nuevos campos con la función arcpy.management.CalculateField. Esta función también toma el nombre de capa y el nombre de campo como argumentos, así como una expresión para calcular el campo. Su expresión utilizará la función int() para convertir los valores del campo de texto alert a enteros.

  2. Ejecute las siguientes líneas:
    # Calculate alert_level field
    arcpy.management.CalculateField('alert_stations', 'alert_level', "int(!alert!)")
    arcpy.management.CalculateField('alert_areas', 'alert_level', "int(!alert!)")

    Se calculan los campos.

    Sugerencia:

    Si desea comprobar que los campos se han calculado correctamente, haga clic con el botón derecho en la capa alert_stations o alert_areas y seleccione Tabla de atributos. Desplácese hasta el final de la tabla para confirmar que se ha agregado el campo Alert Level con valores comprendidos entre 0 y 4.

    A continuación, cambiará la simbología de la capa alert_stations en base al campo nuevo. Primero, creará variables para representar el proyecto (p) y mapa (m) actuales. También creará las variables para la capa alert_stations (points_lyr) y su simbología (points_sym).

  3. Ejecute las siguientes líneas:
    # Symbology
    p = arcpy.mp.ArcGISProject("CURRENT")
    m = p.listMaps('Map')[0]
    # Points
    points_lyr = m.listLayers('alert_*')[0]
    points_sym = points_lyr.symbology
    Nota:

    Si utiliza una versión localizada de ArcGIS Pro, su mapa tendrá localizado el nombre. Tendrá que ajustar el código para sustituir Map por el nombre de su mapa.

    A continuación, actualizará el renderizador. Actualmente, los símbolos se renderizan con el tipo SimpleRenderer (símbolo único). Para simbolizar entidades de otra manera en base a un campo, cambiará el renderizador a GraduatedSymbolsRenderer (símbolos graduados).

    También establecerá el renderizador para que utilice el campo alert_level como campo de clasificación y ordene los datos en cuatro clases (0 a 1, 1 a 2, 2 a 3 y 3 a 4). Para cada clase, definirá el tamaño y el color para que los tamaños aumenten con los niveles de alerta más elevados y los colores cambien de azul a rojo.

  4. Ejecute las siguientes líneas:
    # 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]}]

    A continuación, creará un bucle for para aplicar los tamaños y colores que especificó para cada clase. Sus clases están contenidas en una lista numérica del 1 al 4. Utilizará i (para el entero) como una variable de marcador de posición para representar las clases numeradas.

  5. Ejecute las siguientes líneas:
    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]
    Nota:

    Si utiliza una versión localizada de ArcGIS Pro, deberá ajustar el código para utilizar la versión localizada de la palabra Circle. Es posible que necesite realizar ajustes similares en pasos posteriores.

    El bucle recorrerá todos los enteros del rango especificado (4). Para el primer entero, se utilizará la primera etiqueta, el límite superior, el tamaño y el color de las listas que ha creado anteriormente. Para el segundo entero, se utilizará una segunda serie de valores, así hasta el final del rango.

    Por último, ejecutará una línea para actualizar la simbología de la capa en función de las líneas ejecutadas anteriormente.

  6. Ejecute las siguientes líneas:
    # Update
    points_lyr.symbology = points_sym

    La simbología se actualiza. (Su mapa puede diferir de la imagen de ejemplo debido a que los datos de origen pueden ser más recientes).

    Mapa con la simbología de puntos actualizada

    Utilizando código similar, cambiará la simbología de la capa alert_areas. Primero, creará variables para la capa (polygons_lyr) y su simbología (polygons_sym).

  7. Ejecute las siguientes líneas:
    # Polygons
    polygons_lyr = m.listLayers('alert_*')[1]
    polygons_sym = polygons_lyr.symbology

    A continuación, actualizará el renderizador y creará cuatro clases que coincidan con las que creó para la capa de puntos.

  8. Ejecute las siguientes líneas:
    # 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]}]

    Por último, creará un bucle para cambiar las etiquetas, el tamaño y el color de cada clase y actualizar la simbología de la capa.

  9. Ejecute las siguientes líneas:
    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

    La simbología se actualiza. (Es posible que deba acercarse para verla con claridad).

    Mapa con la simbología de polígono actualizada

  10. Guarde el proyecto.

Publicar las capas

A continuación, publicará las capas en ArcGIS Online o un portal de ArcGIS Enterprise.

  1. Compruebe que tiene una sesión iniciada en una cuenta de ArcGIS Online (o un portal de ArcGIS Enterprise con una cuenta de usuario nominal).
    Nota:

    Si tiene una sesión iniciada, el nombre de su cuenta aparece en la esquina superior derecha de ArcGIS Pro.

  2. En la cinta, haga clic en la pestaña Compartir. En el grupo Compartir como, haga clic en Capa web.

    Botón Capa web en el grupo Compartir como

  3. En el panel Compartir como capa web, ajuste los siguientes parámetros:
    • En Nombre, escriba Coral Reef Watch y agregue su nombre o sus iniciales al final.
    • En Resumen, escriba Últimos datos sobre el riesgo de decoloración de los corales de la NOAA.
    • En Etiquetas, escriba NOAA, Decoloración de corales y Niveles de alerta, pulsando Intro entre cada etiqueta.
    • En Tipo de capa, confirme que Entidad esté seleccionado.

    Parámetros de detalles de los elementos y tipo de capa

  4. Haga clic en Analizar.

    Se analiza la capa para garantizar que no haya ningún error que pueda impedir la publicación. El análisis no devuelve ningún error, pero sí varias advertencias relacionadas con la plantilla de entidades y la fuente de datos. Para los fines de este ejercicio, puede hacer caso omiso de estas advertencias.

  5. Haga clic en Publicar.

    Se ejecuta la herramienta. Aparece un mensaje en la parte inferior del panel que confirma que la capa web se ha publicado.

  6. Guarde el proyecto.

    A continuación, comprobará que la capa se ha publicado correctamente agregándola a un mapa web.

  7. Inicie sesión en su cuenta de organización de ArcGIS o portal de ArcGIS Enterprise.
  8. En la cinta, haga clic en Contenido.

    Opción Contenido de la cinta

    Se han agregado dos nuevos elementos a la página Contenido: la capa de entidades Coral Reef Watch y la definición de servicio.

  9. En la capa de entidades Coral Reef Watch, haga clic en el botón de opciones (los tres puntos horizontales) y seleccione Abrir en Map Viewer.

    Opción Abrir en Map Viewer

    Se abre un mapa web con las capas que ha creado.

En esta lección, utilizó Python para recopilar los datos más recientes del programa Coral Reef Watch, los convirtió en dos clases de entidad y los simbolizó. Luego, publicó las capas como un servicio de entidades. En la siguiente lección, desarrollará una rutina de feed para descargar automáticamente los datos más recientes del Coral Reef Watch cuando estén disponibles.


Crear una rutina de feed

En la lección anterior, recopiló, representó cartográficamente y publicó los últimos datos del programa Coral Reef Watch de la NOAA. Estos datos muestran información sobre la decoloración de los corales en un momento fijo del tiempo, aunque los datos se actualizan con frecuencia. ¿Cómo puede actualizar rápidamente su mapa cada vez que la NOAA actualiza sus datos?

En esta lección, desarrollará una rutina de feed. Las rutinas de feed descargan contenido automáticamente, lo procesan y publican un dataset. Su rutina de feed incluirá el flujo de trabajo de Python que utilizó en la lección anterior.

Crear un script independiente

En lugar de ejecutar su script en ArcGIS Pro como hizo en la lección anterior, creará un script independiente en un editor de texto que pueda guardar y ejecutar con un solo comando. Este script contendrá su rutina de feed y seguirá las directrices de metodología Aggregated Live Feed (ALF).

La metodología ALF es un conjunto de directrices, herramientas y funciones utilizadas para la implementación de una rutina de feed en directo en un entorno de producción. Sus herramientas permiten la automatización de la implementación de la rutina con supervisión mínima. La metodología ALF encapsula los pasos de una rutina de feed en directo y agrega componentes para mejorar el flujo de trabajo general. Estos componentes agregan la funcionalidad para registrar cada paso ejecutado en un registro, descomprimir archivos de forma eficiente y enviar correos electrónicos automáticos si algo falla.

Nota:

Para obtener más información sobre la metodología ALF, puede unirse al grupo Aggregated Live Feed Community. También puede descargar y revisar el documento Metodologías de feed en directo agregado.

  1. Abra un nuevo archivo en un editor de texto sin formato.
    Nota:

    Si no tiene un editor de texto sin formato, puede descargar Notepad++ de forma gratuita. También puede utilizar entornos de desarrollo integrado (IDE) de Python, por ejemplo, PyCharm, PyScripter o Spyder. En las imágenes de ejemplo de esta lección se utiliza Notepad++.

    Primero, guardará el archivo como archivo de script de Python. Algunos editores de texto, incluido Notepad++, resaltan la sintaxis dependiendo del lenguaje de codificación que se utilice, lo que puede ser útil al escribir código.

  2. En la cinta de su editor de texto, haga clic en Archivo y elija Guardar o Guardar como. Guarde el archivo como coral_reef_exercise.py en la ubicación que desee.
    Nota:

    El proceso de guardar el archivo como archivo de Python (.py) puede diferir dependiendo del programa que esté utilizando.

    Lo primero que hizo cuando representó cartográficamente los datos más recientes en la lección anterior fue importar el módulo sys, por lo que agregará una sentencia para que lo haga al comienzo de su rutina de feed.

  3. En el editor de texto, cree la línea import sys.

    También definirá una nueva función denominada feedRoutine que requiera los argumentos url (la URL a los datos) y workGDB (la ruta a la geodatabase de archivos que creó anteriormente). Más tarde, definirá esta función para que ejecute los pasos para recuperar y representar cartográficamente los datos, aunque por ahora utilizará un valor de marcador de posición pass para sustituirlos.

    Además, agregará la sentencia __name__ = "__main__", que permite que el script se ejecute como rutina independiente (por ejemplo, ejecutándolo en la ventana de comandos). En este caso, el script independiente ejecutará la función feedRoutine pasándole los argumentos url y workGDB de la ventana de comandos a través de la sentencia sys.argv[1:].

  4. Presione Intro dos veces. Copie y pegue las siguientes líneas a partir de la línea 3:
    def feedRoutine (url, workGDB):
        pass
    if __name__ == "__main__":
    	[url, workGDB] = sys.argv[1:]
    	feedRoutine (url, workGDB)
    Nota:

    Las sangrías son importantes para garantizar que el script se ejecute correctamente. Asegúrese de mantener todas las sangrías en el script. No agregue sangrías innecesarias.

    Rutina de feed con las sentencias iniciales

    Importó varios módulos más durante el flujo de trabajo. En lugar de ejecutar la sentencia import de nuevo para cada módulo, hará que el script importe todos los módulos necesarios con la misma función.

  5. Modifique la línea 1 (import sys) para que lea import sys, arcpy, os, tempfile, json. Pulse Intro y cree la línea from urllib import request en la línea 2.

    Las líneas completas deberían quedar como sigue:

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

    Rutina de feed con todos los módulos

    A continuación, empezará a reemplazar el marcador de posición pass con los pasos necesarios para recuperar datos y crear capas. Primero, definirá workGDB como la geodatabase predeterminada (arpy.env.workspace) y creará la geodatabase utilizando la función arcpy.management.CreateFileGDB.

  6. Reemplace la línea 5 (pass) por las líneas siguientes:
    # workGDB and default workspace
        arcpy.env.workspace = workGDB 
        arcpy.management.CreateFileGDB(os.path.dirname(workGDB), os.path.basename(workGDB))
    Nota:

    En función del tamaño de ventana, puede que algunas de las líneas más largas se ajusten automáticamente, como se muestra en la siguiente imagen.

    Rutina de feed con la geodatabase predeterminada definida

    A continuación, agregará un código de marcador de posición para una función de lógica de implementación. Ahora mismo no necesita esta función, pero la utilizará en lecciones posteriores, por lo que es una buena idea agregar un espacio para ella en su script. También agregará un marcador de posición para el código de la lección anterior.

  7. Después de la línea 7, pulse Intro dos veces y elimine las sangrías. A partir de la línea 9, copie y pegue las siguientes líneas (incluidas las sangrías):
    ### Placeholder for retrieving and mapping data ###
        # Deployment Logic
        deployLogic()
        # Return
        return True
    def deployLogic():
        pass

    Rutina de feed con marcadores de posición para la lógica de implementación

    Nota:

    Es importante utilizar espacios en lugar de tabulaciones para las sangrías.

    A continuación, reemplazará el marcador de posición para recuperar y representar cartográficamente datos con el código que ejecutó en la lección anterior.

    Este código no incluirá código para cambiar la simbología. La simbología para las capas ya se ha guardado en el proyecto ArcGIS Pro y en el mapa web, por lo que no necesita cambiar de nuevo la simbología. (Se mantendrá el código para agregar y calcular los campos alert_level, ya que estos campos se necesitan para la simbología existente).

    Además, este código incluirá varias funciones print() que incluyen sentencias para mantenerle al día sobre qué líneas se están ejecutando.

  8. Reemplace la línea 9 (### Placeholder for retrieving and mapping data ###) por las líneas siguientes:
    # 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!)")

    A continuación, agregará tres funciones print() más en otras partes del script, incluida una que le informe de que el script se ha completado.

  9. Después de la línea 5 (# workGDB and default workspace), pulse Intro. En la línea 6, cree la siguiente línea con sangría:
    print("Creating workGDB...")

    Rutina de feed con la función print() agregada al bloque workGDB

  10. Después de la línea 43 (# Deployment Logic), pulse Intro. En la línea 44, cree la siguiente línea con sangría:
    print("Deploying...")
  11. Después de la línea 47 (# Return), pulse Intro. En la línea 48, cree la siguiente línea con sangría:
    print("Done!")

    En función de cómo haya creado el script, es posible que todavía tenga sangrías con tabulaciones.

  12. Compruebe todo el script para asegurarse de que todas las sangrías se han hecho con espacios en lugar de tabulaciones.
    Sugerencia:

    Si está utilizando Notepad++, puede convertir automáticamente las tabulaciones en espacios. En la cinta, haga clic en Editar, apunte a Operaciones en blanco y seleccione TABULACIÓN a espacio.

  13. Guarde el script.
    Nota:

    Si desea comprobar si ha creado su script correctamente, puede compararlo con un script de ejemplo.

    A continuación, probará el script.

  14. Abra el menú Inicio de Windows. Busque y abra la ventana de comandos de Python.

    Primero, vaya al directorio en el que guardó su archivo coral_reef_exercise.py.

    Nota:

    En las imágenes de ejemplo, el archivo coral_reef_exercise.py se guardó en la carpeta Documentos (C:\Users\Documents). Puede obtener la ruta a su archivo navegando hasta él en un explorador de archivos como el Explorador de Windows y copiando la ruta de la parte superior del explorador.

  15. En la ventana de comandos de Python, escriba cd y presione la barra espaciadora. Copie la ruta al directorio donde guardó su archivo de Python. Si la ruta contiene espacios, agregue comillas al inicio y al final de la ruta.

    Ventana de comandos de Python con el comando para cambiar el directorio

  16. Pulse Intro.

    Se ha cambiado el directorio. A continuación, ejecutará el script. Utilizará el comando python e incluirá el nombre del archivo, la URL al sitio web con los datos de los arrecifes de coral y la ruta y el nombre de la geodatabase.

  17. Ejecute el siguiente comando:

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

    El comando tarda unos segundos en ejecutarse. Mientras se ejecuta, las funciones print() le ofrecen información sobre el progreso.

    Ventana de comandos de Python con el script independiente

    Las capas de la geodatabase Work se actualizan con los datos más recientes (que posiblemente sean los mismos que los datos que utilizó en la lección anterior). Por ahora, el script no actualiza las capas que aparecen en el mapa de su proyecto de ArcGIS Pro ni en su mapa web. Agregará dicha funcionalidad más tarde utilizando la función deployLogic().

Agregar funcionalidad de script avanzada

Su script funciona, pero todavía puede mejorarlo. Primero, ajustará el script para que solo cree una geodatabase si todavía no existe una.

Creará una sentencia if utilizando la función arcpy.Exists para comprobar si existe el espacio de trabajo. Si es así, eliminará todas las clases de entidad existentes que comiencen por alert_, de modo que se puedan reemplazar por clases de entidad nuevas. Puede representar ambas capas de alerta con la cadena de caracteres alert_*, con un asterisco que representa a cualquier texto.

  1. En caso necesario, abra su script coral_reef_exercise en un editor de texto.
  2. Reemplace las líneas de la 5 a la 8 (las líneas para crear el espacio de trabajo predeterminado) con las siguientes líneas:
    # 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))

    Script avanzado para comprobar las workGDB existentes

    Si el script se ejecuta en un equipo sin acceso a Internet, el archivo JSON en línea no se descargará. Para detectar este común error, generará la excepción estándar URLError, que informa al usuario de que la URL no se encuentra disponible.

  3. Reemplace la línea 18 (response = request.urlretrieve(url, filename)) por las líneas siguientes (asegúrese de que la primera línea esté sangrada):
    try:
            response = request.urlretrieve(url, filename)
        except URLError:
            raise Exception("{0} not available. Check internet connection or url address".format(url))

    Script avanzado para generar URLError

    A continuación, registrará los pasos en ejecución en un archivo de registro. Ya imprime mensajes sobre cada parte del script en la ventana de comandos, por lo que agregará una función logging.info() tras cada función print(). Esta función registra mensajes que pueden ser útiles para la depuración si se generan errores con el script. El mensaje que registra incluirá la fecha y hora de registro del mensaje.

    Primero, modificará su script para importar los módulos logging y datetime. También importará la excepción URLError que utilizó previamente.

  4. Reemplace las líneas 1 y 2 (las líneas de importación) con las siguientes líneas:
    import sys, os, tempfile, json, logging, arcpy
    import datetime as dt
    from urllib import request
    from urllib.error import URLError

    A continuación, utilizará la función logging.basicConfig() para configurar el archivo de registro en el que se registrará el mensaje. También establecerá una variable log_format que defina cómo se mostrarán la fecha y la hora.

  5. Agregue las siguientes líneas después de la línea 6 (def feedRoutine):
    # Log file
        logging.basicConfig(filename="coral_reef_exercise.log", level=logging.INFO)
        log_format = "%Y-%m-%d %H:%M:%S"

    Script avanzado para configurar el registro

    A continuación, agregará funciones logging.info() que agregan mensajes al registro. Estas funciones registrarán la fecha y la hora con la función dt.datetime.now() y modificarán el formato de fecha y hora utilizando la variable log_format que creó anteriormente. Agregará estas funciones después de cada función print().

  6. Después de la línea 11 (print("Starting workGDB...")), agregue la siguiente línea (asegúrese de que esté sangrada):
    logging.info("Starting workGDB... {0}".format(dt.datetime.now().strftime(log_format)))
  7. Después de la línea 21 (print("Downloading data...")), agregue la siguiente línea (asegúrese de que esté sangrada):
    logging.info("Downloading data... {0}".format(dt.datetime.now().strftime(log_format)))
  8. Después de la línea 47 (print("Creating feature classes...")), agregue la siguiente línea (asegúrese de que esté sangrada):
    logging.info("Creating feature classes... {0}".format(dt.datetime.now().strftime(log_format)))
  9. Después de la línea 59 (print("Deploying...")), agregue la siguiente línea (asegúrese de que esté sangrada):
    logging.info("Deploying... {0}".format(dt.datetime.now().strftime(log_format)))
  10. Después de la línea 64 (print("Done!")), agregue la siguiente línea (asegúrese de que esté sangrada):
    logging.info("Done! {0}".format(dt.datetime.now().strftime(log_format)))

    También registrará la excepción URLError utilizando la función logging.exception().

  11. Después de la línea 27 (except URLError), agregue las siguientes líneas (asegúrese de que la primera línea esté sangrada):
    logging.exception("Failed on: request.urlretrieve(url, filename) {0}".format(
                              dt.datetime.now().strftime(log_format)))

    Por último, cerrará el archivo de registro al final del script con la función logging.shutdown().

  12. Al final de la línea 63, pulse Intro dos veces. En la línea 65, agregue las siguientes líneas:
    # Close Log File
        logging.shutdown()

    Script avanzado para cerrar el archivo de registro

  13. Asegúrese de que su script no contiene ninguna sangría con tabulación. Guarde su script.
    Nota:

    Si desea comprobar si ha creado su script correctamente, puede compararlo con un script de ejemplo.

En esta lección, creó una rutina de feed que se puede ejecutar como script independiente utilizando la ventana de comandos. También agregó funcionalidad avanzada. En la siguiente lección, adaptará la rutina de feed para actualizar las clases de entidad locales de su proyecto de ArcGIS Pro.


Actualizar clases de entidad locales

En la lección anterior, creó una rutina de feed. Cuando esta rutina de feed se ejecuta, descarga los datos más recientes de la NOAA sobre decoloración de corales y crea dos clases de entidad, una para datos de puntos y otra para datos de polígonos. Estas clases de entidad se encuentran en la geodatabase Work. Sin embargo, el script no actualiza las capas de su proyecto de ArcGIS Pro, que se encuentran en la geodatabase Live.

En esta lección, adaptará su rutina de feed para que actualice automáticamente las capas alert_stations y alert_areas de su proyecto de ArcGIS Pro.

Definir la función de lógica de implementación

Su rutina de feed contiene un script de marcador de posición para una función de lógica de implementación denominada deployLogic(). En la metodología ALF, el proceso de lógica de implementación es la parte de la rutina de feed que toma la información más reciente obtenida de Internet (en su caso, los datos ubicados en la geodatabase Work) y sobrescribe los datos en directo (las clases de entidad ubicadas en la geodatabase Live).

  1. Cree una copia de su script coral_reef_exercise.py llamada ejercicio_arrecifes_de_coral_local.py. Abra la copia en un editor de texto o IDE de Python.

    A continuación, modificará el script para que el módulo shutil se importe. Este módulo contiene varias operaciones de archivo avanzadas que serán necesarias para definir la función de lógica de implementación.

  2. En el script coral_reef_exercise_local.py, en la línea 1, agregue shutil a la lista de módulos.

    Función import con el módulo shutil

    A continuación, agregará a la rutina de feed un tercer argumento denominado liveGDB, que representará la geodatabase Live donde se encuentran las capas de su proyecto.

  3. En la línea 6, agregue liveGDB a la lista de argumentos feedRoutine.

    Rutina de feed con el argumento liveGDB

    También agregará este argumento al comando sys.argv[1:] al final del script. De esta forma, los usuarios pueden ofrecer la ruta y el nombre de la geodatabase Live al ejecutar el script en la ventana de comandos.

  4. En la línea 77, agregue liveGDB a la lista entre corchetes. En la línea 78, agregue liveGDB a la lista de argumentos feedRoutine.

    Rutina de feed con argumentos liveGDB adicionales

    La función deployLogic() tomará dos argumentos, workGDB y liveGDB, por lo que agregará estos argumentos en los que se llama a la función y donde se definen.

  5. En las líneas 63 y 73, reemplace deployLogic() por deployLogic(workGDB, liveGDB).

    Rutina de feed con los argumentos deployLogic()

    A continuación, definirá la función deployLogic(). Utilizará un bucle for para copiar todos los elementos del argumento workGDB y los utilizará para reemplazar los elementos del argumento liveGDB. Utilizará la función os.walk() para enumerar los archivos, y la función shutil.copy2() para copiarlos y reemplazarlos. De acuerdo con la metodología ALF, también hará que el script ignore cualquier archivo .lock.

  6. En la línea 74, reemplace pass (el marcador de posición) por las siguientes líneas (asegúrese de que la primera línea esté sangrada):
    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))

    Script para definir la función deployLogic()

    Nota:

    Esta rutina de feed reemplazará automáticamente las clases de entidad de su proyecto de ArcGIS Pro, aunque se deben tomar algunas precauciones. Las nuevas clases de entidad deben ser coherentes con la estructura de datos anterior; los campos que faltan u otros nombres pueden dañar el proyecto de mapa.

  7. Asegúrese de que su script no contiene ninguna sangría con tabulación. Guarde su script.
    Nota:

    Si desea comprobar si ha creado su script correctamente, puede compararlo con un script de ejemplo.

Ejecutar el script independiente

A continuación, ejecutará su rutina de feed adaptada y actualizará su proyecto de ArcGIS Pro.

Es probable que la NOAA no haya actualizado sus datos desde que representó cartográficamente los últimos datos en su proyecto. Si ejecutase ahora el script, probablemente no vería ningún cambio en los datos. Para probar que su script funciona correctamente, actualizará los datos utilizando un archivo histórico alojado por Learn ArcGIS.

  1. En caso necesario, abra su proyecto Decoloración de corales en ArcGIS Pro.
  2. En caso necesario, abra la ventana de comandos de Python y utilice el comando cd para ir hasta el directorio donde guardó su archivo ejercicio_arrecifes_de_coral_local.py.
  3. En la ventana de comandos, ejecute el siguiente comando:

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

    El comando se ejecuta.

    Ventana de comandos de Python con el comando ejecutado

    Nota:

    Una vez que el programa Coral Reef Watch de la NOAA actualiza sus datos, puede reemplazar la URL al archivo histórico (https://downloads.esri.com/LearnArcGIS/update-real-time-data-with-python/vs_polygons.json) con la URL a los datos de la NOAA (https://coralreefwatch.noaa.gov/vs/vs_polygons.json).

    Aunque la ventana indica que el comando se ha ejecutado correctamente, no ha habido ningún cambio en el mapa en ArcGIS Pro. Reiniciará ArcGIS Pro y refrescará la visualización del mapa para mostrar los cambios.

  4. Cierre ArcGIS Pro (guarde si se le pide). Vuelva a abrir el proyecto Decoloración de corales.

    Al reiniciar ArcGIS Pro puede que también se refresque la visualización del mapa. De no ser así, puede refrescar la visualización manualmente.

  5. En caso necesario, en la esquina inferior derecha de la vista Mapa, haga clic en el botón Refrescar.

    Botón Refrescar

    El mapa se refresca y muestra los datos históricos (desde el 19 de febrero de 2019).

    Mapa con datos históricos

    También puede verificar que los datos de atributos se han actualizado.

  6. En el mapa, haga clic en cualquier entidad de estación o área.

    Se abre el elemento emergente de la entidad. El campo fecha indica 2019-02-19, la fecha de los datos históricos.

    Ventana emergente con la fecha histórica

  7. Cierre el elemento emergente.

En esta lección, desarrolló y ejecutó una rutina de feed para actualizar un dataset local. Probó la rutina de feed actualizando el mapa con datos históricos, pero al reemplazar la URL utilizada en el comando de Python puede aplicar el mismo proceso a los datos más recientes de la NOAA. En la siguiente lección, desarrollará y ejecutará una rutina de feed similar para actualizar un servicio de entidades en línea.


Actualizar un servicio de entidades en línea

En la lección anterior, desarrolló y ejecutó una rutina de feed para actualizar las clases de entidad locales de su proyecto de ArcGIS Pro. En la siguiente lección, seguirá un proceso similar para desarrollar y ejecutar una rutina de feed para actualizar un servicio de entidades en línea en un mapa web.

Obtener el Id. y la definición de servicio

Al actualizar una clase de entidad local, utilizó la geodatabase Live como la ubicación en la que se copiarían los nuevos datos. Los servicios de entidades en línea no se almacenan en geodatabases, por lo que, en su lugar, necesitará el archivo de definición de servicio y el Id. de elemento para consultar y reemplazar el servicio de entidades con ArcGIS API for Python.

En la primera lección, publicó un servicio de entidades con los datos más recientes. Utilizará este servicio de entidades como el destino de las actualizaciones. Primero, descargará su archivo de definición de servicio.

  1. En caso necesario, inicie sesión en su cuenta de organización de ArcGIS o en un portal de ArcGIS Enterprise.
  2. Vaya a la página Contenido y acceda a la carpeta donde se encuentra la capa de entidades Coral Reef Watch y el archivo de definición de servicio.
    Nota:

    El archivo de definición de servicio se creó cuando publicó la capa. Dado que utilizará este archivo para actualizar el servicio de entidades, cualquier cambio realizado en el servicio de entidades después de su publicación (por ejemplo, cambios en los metadatos o la simbología) se perderán al actualizar el servicio de entidades. Cualquier aplicación o mapa web que incluya el servicio de entidades también se verá afectado.

    La práctica recomendada para evitar la pérdida de los cambios en el servicio de entidades es crear una capa de visualización. Cualquier mapa o aplicación web que utilice la capa de entidades puede apuntar a la capa de visualización en lugar de al servicio de entidades, y cualquier cambio en la capa de visualización se conserva cuando se actualiza el servicio de entidades. Para crear una capa de visualizaciones, abra la página de detalles de la capa de entidades y haga clic en Crear capa de visualización. Encontrará más información en la página de documentación.

  3. En el archivo de definición de servicio Coral Reef Watch, haga clic en el botón de opciones (los tres puntos) y seleccione Descargar.

    Descargar archivo de definición de servicio

    El archivo de definición de servicio (.sd) se descarga a su equipo.

  4. Copie el archivo de definición de servicio a la carpeta Temp de su unidad C.

    A continuación, copiará el Id. de elemento de la capa.

  5. En la capa de entidades Coral Reef Watch, haga clic en el botón de opciones y seleccione Ver detalles del elemento.

    Se abre la página de detalles de la capa de entidades. El Id. se encuentra en la URL.

  6. En la URL de la página de detalles, copie la cadena de número y letras que aparece después de id= (en la imagen de ejemplo, esta cadena es 2dcf249f5cd54a609d51acba6e0ba029).
    Nota:

    Su Id. de elemento de la capa de entidades será distinta.

    Id. de elemento de la capa de entidades

  7. Pegue el Id. en un archivo de texto vacío o en un lugar al que pueda acceder fácilmente.

Definir la función de lógica de implementación

A continuación, hará otra copia de su rutina de feed original. Luego, definirá la función deployLogic() utilizando un script que reemplace un servicio de entidades en línea por datos descargados de la geodatabase Work.

  1. Cree una copia de su script coral_reef_exercise.py original denominada ejercicio_arrecifes_de_coral_en_línea.py. Abra la copia en un editor de texto o IDE de Python.

    Para el script que va a crear, necesitará los módulos fnmatch, shutil, subprocess y arcgis así como el submódulo GIS.

  2. En el script coral_reef_exercise_online.py, en la línea 1, agregue fnmatch, shutil, subprocess y arcgis a la lista de módulos. Pulse Intro y agregue la línea from arcgis.gis import GIS a la línea 2.

    Las líneas completas deberían quedar como sigue:

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

    Rutina de feed con líneas para importar módulos y submódulos

    Cuando definió la función de lógica de implementación para actualizar una clase de entidad local, agregó un argumento a la rutina de feed denominado liveGDB, que podía utilizar para proporcionar la ruta a la geodatabase adecuada cuando ejecutó el script. En esta rutina de feed, agregará parámetros para el Id. de elemento del servicio de entidades, el archivo de definición de servicio y el nombre de servicio.

  3. En la línea 7, agregue los argumentos itemid, original_sd_file y service_name a la lista de argumentos feedRoutine.

    Las líneas completas deberían quedar como sigue:

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

    Argumentos agregados a la función feedRoutine

    También agregará estos parámetros al comando sys.argv[1:] al final del script.

  4. En las líneas 78 y 79, agregue itemid, original_sd_file y service_name a ambas listas de argumentos.

    Las líneas completas deberían quedar como sigue:

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

    Argumentos agregados al comando sys.argv[1:]

    También agregará estos argumentos (y el argumento workGDB) a la función deployLogic() donde se define y se llama.

  5. En las líneas 64 y 74, reemplace deployLogic() con deployLogic(workGDB, itemid, original_sd_file, service_name).

    Argumentos para la función deployLogic donde se define y llama

    A continuación, definirá la función deployLogic(). Esta función llevará a cabo varias tareas. Primero, obtendrá el elemento de servicio de entidades de ArcGIS Online o de su portal de ArcGIS Enterprise (representado por el argumento itemid) utilizando la función gis.content.get().

    También creará una variable gis definida por la función GIS(). Los argumentos de esta función incluirán la URL del portal de su organización (para ArcGIS Online, la URL será https://arcgis.com) y su nombre de usuario y la contraseña de la cuenta.

  6. En la línea 75, reemplace el script de marcador de posición (pass) con las siguientes líneas:
    # 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))
    Nota:

    Si usa una cuenta de ArcGIS Online, el parámetro url es opcional.

  7. En la línea 76, reemplace los parámetros username y password con el nombre de usuario y contraseña de su cuenta de ArcGIS. Si su cuenta es de un portal de ArcGIS Enterprise, reemplace el parámetro url con la URL a su portal.
    Precaución:

    Tenga cuidado al compartir el script con otras personas, dado que contiene su contraseña. Existe funcionalidad de script avanzada para ayudarle a proteger sus credenciales.

    A continuación, la función deployLogic() desempaquetará el contenido del archivo de definición de servicio (original_sd_file). Lo hará utilizando 7-Zip, un programa que se encuentra de forma predeterminada en muchos equipos con Windows. Antes de agregar el script que utilizará 7-Zip para desempaquetar el archivo, se asegurará de que lo tiene en su equipo y lo agregará a la variable de entorno Path en Windows. Al agregarlo a esta variable de entorno, podrá llamar al programa utilizando su script.

  8. En caso necesario, descargue la versión adecuada de 7-Zip para su equipo e instálelo.

    El proceso de edición de una variable de entorno difiere en función de su sistema operativo, pero suele poder hacerse mediante la ventana Variables de entorno.

  9. En su equipo, abra el Panel de control. Haga clic en Sistema y seguridad, después en Sistema y, por último, en Configuración avanzada del sistema. En la ventana Propiedades del sistema, haga clic Variables de entorno. (La ruta exacta puede diferir en función de su sistema operativo).
  10. En la ventana Variables de entorno, en Variables del sistema, seleccione la variable Ruta y haga clic en Editar.

    En función de su sistema operativo, se abre la ventana Editar variable de entorno o la ventana Editar variable del sistema. El proceso para agregar una nueva variable difiere en cada ventana.

  11. Si se abre la ventana Editar variable de entorno, haga clic en Nuevo y agregue C:\Archivos de programa\7-Zip como nueva variable. Si se abre la ventana Editar variable del sistema, desplácese hasta el final del parámetro de valor de la variable y pegue ;C:\Archivos de programa\7-Zip al final (asegurándose de no eliminar nada del texto existente).
  12. Haga clic en Aceptar. En la ventana Variable de entorno, haga clic en Aceptar.

    A continuación, creará el script. Incluirá un mensaje de error que se genera si no puede encontrar 7-Zip en la variable de entorno Ruta.

  13. En el script coral_reef_exercise_online.py, después de la línea 80, agregue las siguientes líneas:
    # 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)

    Después de que el script obtenga el servicio de entidades y descomprima su archivo de definición de servicio, reemplazará sus datos con los datos descargados a Work.gdb. Utilizará Live.gdb como carpeta intermediaria que se puede comprimir en un nuevo archivo de definición de servicio.

    Su script utilizará la función shutil.rmtree() para eliminar Live.gdb y la función os.mkdir() para crearla de nuevo, eliminando el contenido existente de la geodatabase.

  14. Agregue las siguientes líneas después de la línea 89:
    # 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))

    A continuación, el script comprimirá Live.gdb en un nuevo archivo de definición de servicio, al que se hace referencia como updated_sd.

  15. Agregue las siguientes líneas después de la línea 97:
    # 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)

    Por último, el script utilizará el método manager del elemento (arcgis.features.FeatureLayerCollection.fromitem(item).manager) para sobrescribir el servicio de entidades con los datos nuevos.

  16. Agregue las siguientes líneas después de la línea 102:
    # Replace file
        manager = arcgis.features.FeatureLayerCollection.fromitem(item).manager
        status = manager.overwrite(updated_sd)
        # Return
        return True
  17. Asegúrese de que su script no contiene ninguna sangría con tabulación. Guarde su script.
    Nota:

    Si desea comprobar si ha creado su script correctamente, puede compararlo con un script de ejemplo.

Ejecutar el script independiente

A continuación, ejecutará la rutina de feed en la ventana de comando de Python y actualizará el servicio de entidades en línea Coral Reef Watch. Al igual que en la lección anterior, para los fines de este ejercicio actualizará el servicio de entidades con datos históricos.

  1. En caso necesario, en ArcGIS Online o en su portal de ArcGIS Enterprise, abra la capa de entidades Coral Reef Watch en Map Viewer.
  2. En caso necesario, abra la ventana de comandos de Python y utilice el comando cd para ir hasta el directorio donde guardó su archivo ejercicio_arrecifes_de_coral_local.py.
    Nota:

    Si agregó 7-Zip a la variable de entorno Path, puede que necesite reiniciar la ventana de comandos de Python.

  3. Pegue el siguiente comando (no lo ejecute todavía):

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

    Antes de ejecutar el comando, agregará los argumentos restantes que se requieren: el Id. de elemento, el archivo original de definición de servicio y el nombre de servicio.

  4. Al final del comando, pulse la barra espaciadora y pegue el Id. de elemento del servicio de entidades.
    Nota:

    El Id. de elemento es una cadena de letras y números ubicada en la URL del servicio de entidades, por ejemplo, 2dcf249f5cd54a609d51acba6e0ba029.

    Anteriormente descargó el archivo de definición de servicio original y lo copió en su carpeta Temp. El nombre de servicio es Coral_Reef_Watch, con su nombre o sus iniciales al final.

  5. Presiones la barra espaciadora y pegue C:\Temp\Coral_Reef_Watch.sd Coral_Reef_Watch. Cambie la definición y el nombre de servicio para que coincidan con el nombre de su definición de servicio.

    Su comando completado tiene un formato similar al del siguiente comando (pero con otro Id. de elemento, nombre de archivo de definición de servicio y nombre de servicio):

    python ejercicio_arrecifes_de_coral_en_línea.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

    Comando de ejemplo en la ventana de comandos de Python

  6. Ejecute el comando.

    El comando se ejecuta. La ventana de comandos devuelve mucha información sobre 7-Zip y los datos que se extraen. Cuando el comando finaliza, la ventana de comandos devuelve la línea Done.

    Ventana de comandos que devuelve el valor Done

    A continuación, visualizará los cambios en su mapa web.

  7. Refresque su mapa web utilizando el botón Refrescar o Volver a cargar del navegador.

    El mapa se actualiza con datos del 19 de febrero de 2019.

    Mapa final con datos del 19 de febrero de 2019

  8. Haga clic en cualquier estación o área para abrir su ventana emergente.

    El campo fecha indica 2019-02-19, lo que confirma que los datos se han actualizado correctamente.

    El campo fecha en la ventana emergente

  9. Cierre el elemento emergente. Cierre el mapa web sin guardar. (Como alternativa, guarde el mapa web si lo desea).

En esta lección, ha creado rutinas de feed para actualizar automáticamente capas web y locales con los datos más recientes de la NOAA. En la lección también se introdujeron temas básicos y avanzados de Python y se utilizó la metodología ALF para desarrollar e implementar una rutina de feed. Para los fines de la lección, utilizó datos históricos para actualizar las capas, pero puede ejecutar el mismo script con la URL a los datos de la NOAA.

Puede ejecutar este script con frecuencia para mantener actualizadas sus capas. Al configurar una tarea en Windows, puede hacer que el script se ejecute automáticamente en un intervalo determinado, por lo que se puede implementar con datos en tiempo real.

Encontrará más lecciones en la Galería de lecciones de Learn ArcGIS.