¿Secuencias de comandos de Python que se ejecutan dentro de ArcMap frente a las que se ejecutan afuera?

Estoy empezando a entrar en Python scripting por trabajo.

Actualmente estoy creando un script para automatizar un proceso.

Básicamente, le pregunta al usuario el nombre del cliente, obtiene una proyección si está disponible, crea un directorio en C: unidad para el cliente, crea una geodatabase de archivos específica para el cliente, crea un conjunto de datos requerido y crea clases de entidad específicas para los datos de los clientes. Eventualmente, también agregará los campos obligatorios a cada clase de entidad y probablemente algunas otras cosas.

Comencé esto sin saber realmente la etiqueta adecuada de las secuencias de comandos de Python para ArcMap. Pero lo que he creado hasta ahora solo se ejecutará fuera de ArcMap, creo.

¿Es esto aceptable?

En lugar de obtener la entrada del usuario a través de arcpy.getparamaterastext (), que acabo de descubrir, estoy usando raw_input ().

¿Esta bien?

Funciona, simplemente no estoy seguro de si esta es una forma adecuada de hacer secuencias de comandos.

Aquí está el código que tengo hasta ahora.

import sys
import arcpy
import os

#Records name of the client
client = raw_input("Enter the name of the client: (letters and underscores only) \n")

#Records filepath of client to be created
clientpath = "C:/" + client

#Inquires if projection file exists
projection = raw_input("Is there a .prj or .shp available with correct projection? Y or N \n")

#Records the projection location if available
if projection.upper() == "Y":
    spatialr = raw_input("Drag the .prj or .shp here to record the filepath \n")
    nspatialr = spatialr.replace('"', "")
elif projection.upper() == "N":
    alert = raw_input("You must add the spatial reference manually, hit enter to continue. \n")
elif projection.upper() != "N" or "Y":
    exit = raw_input("That is not a valid response. Try again. \n")
    sys.exit()

#Checks if client folder exists; if not, creates one
if not os.path.exists(clientpath):
    os.makedirs(clientpath)

#Variable for file geodatabase location
FGBpath = clientpath + "/" + client + ".gdb"

#Checks if client file geodatabase exists; if not, creates one
if not arcpy.Exists(FGBpath):
    arcpy.CreateFileGDB_management(clientpath, client)

#Variable for dataset location
FDatasetpath = clientpath + "/" + client + ".gdb" + "/Network"

#Checks if dataset exists; if not, creates one
if not arcpy.Exists(FDatasetpath):
    if projection.upper() == "Y":
        arcpy.CreateFeatureDataset_management(FGBpath, "Network", nspatialr)
    elif projection.upper() == "N":
        arcpy.CreateFeatureDataset_management(FGBpath, "Network")

#Variable for cable feature class location
FCcablepath = clientpath + "/" + client + ".gdb" + "/Network" + "/cable"

#Checks if cable feature class exists; if not, creates one
if not arcpy.Exists(FCcablepath):
    if projection.upper() == "Y":
        arcpy.CreateFeatureclass_management (FDatasetpath, "cable", "POLYLINE", "", "", "", nspatialr)
    elif projection.upper() == "N":
        arcpy.CreateFeatureclass_management (FDatasetpath, "cable", "POLYLINE")

#Variable for splice point feature class location
FCsplicepath = clientpath + "/" + client + ".gdb" + "/Network" + "/splice_point"

#Checks if splice point feature class exists; if not, creates one
if not arcpy.Exists(FCsplicepath):
    if projection == 'Y' or projection == 'y':
        arcpy.CreateFeatureclass_management (FDatasetpath, "splice_point", "POINT", "", "", "", nspatialr)
    elif projection == 'N' or projection == 'n':
        arcpy.CreateFeatureclass_management (FDatasetpath, "splice_point", "POINT")

exit = raw_input("\n\n File geodatabase, dataset, and the cable \n and splice point feature classes successfully created. \n\n Hit enter to exit.")

Todavía tengo algo de trabajo que hacer, como agregar los campos necesarios.

La forma en que obtiene sus entradas depende 100% de quién será el usuario final, pero tiene razón, no podrá usar raw_input en ArcMap. Si va a ser el único que use el script, no hay nada de malo en obtener sus entradas a través de raw_input, o rutas de codificación rígidas como variables en su script. Sin embargo, si alguien más usará el script que puede o no tener experiencia en scripts, es mejor usar getParameterAsText () e implementar su script como herramienta de script en ArcMap. La creación de una herramienta de script le dará al usuario una interfaz similar a la utilizada por la mayoría de las herramientas de ESRI (como herramientas estándar como el búfer, etc.).

Una cosa a destacar es que la forma en que ha diseñado sus raw_inputs crea una interacción paso a paso entre el usuario y el script. Si esto se ejecuta usando getParameterAsText () en ArcMap, el paso a paso desaparecerá, y solo será una serie de configuraciones que se ingresan antes de ejecutar el script.

Uno de los propósitos principales para las secuencias de comandos es la automatización. Si va a ejecutar esto en múltiples conjuntos de datos, debe verificar los bucles . Si ha llegado hasta aquí, probablemente haya leído sobre ellos al menos, pero como ejemplo de cómo podría usarlos: digamos que tiene múltiples conjuntos de datos en los que necesita realizar la misma operación. Puede escribir el código para los procesos que deben realizarse una vez, luego incluir un ciclo 'for' que tome una lista de conjuntos de datos y realice la operación en cada uno de ellos.

Para cosas como la referencia espacial, puede 'robar' una referencia espacial de un archivo de forma existente usando arcpy.Describe () , o puede obtener una entrada de referencia espacial usando getParameterAsText () (siempre que defina el parámetro como una entrada de referencia espacial al configurar la herramienta de secuencia de comandos). Usar raw_input para obtener nombres de ruta es un poco engorroso.

Además de las excelentes sugerencias de @ egdetti , puede simplificar enormemente su script haciendo algunas suposiciones en lugar de escribir la lógica if / else para cada pequeña condición.

Por ejemplo:

• En lugar de verificar si cada elemento existe de antemano, simplemente asuma que existe y sobrescríbalo configurando arcpy.env.overwriteOutput = True. Ahora puede tener alguna razón por la que necesita verificar de antemano, pero la mayoría de las veces está bien sobrescribir.

• En lugar de verificar si se configuró la opción de referencia espacial y llamar al mismo comando de dos maneras diferentes, simplemente pase la variable de referencia espacial al comando una vez y deje que maneje cadenas nulas o vacías (lo cual estará bien).

• Úselo os.path.joinpara unir elementos de ruta de archivo en lugar de utilizar la concatenación de cadenas, que está llena de peligros.

  Por ejemplo, en lugar de:

  FGBpath = clientpath + "/" + client + ".gdb"

  Utilizar:

  FGBpath = os.path.join(clientpath, client + ".gdb")