Código

Enumerar todas las Clases de Entidad y Geodatabases Corporativas y sus Metadatos

Este script es útil para auditar metadatos. El script se puede ejecutar en varias geodatabases empresariales y creará un archivo CSV de salida con estas columnas: 'Geodatabase', 'Dataset de Entidad', ' Clase de Entidad', 'Referencia Espacial', 'Recuento de Filas', 'Recuento de Columnas', 'Título de Metadatos', 'Descripción de Metadatos', 'Resumen de Metadatos', 'Créditos de Metadatos', 'Restricciones de Acceso a Metadatos'.

Para usar este script, debe cambiar la Línea 19 para que apunte a sus archivos de conexión SDE.

import csv
import os

from arcpy import Describe
from arcpy import env
from arcpy import GetCount_management
from arcpy import ListDatasets
from arcpy import ListFeatureClasses
from arcpy import ListFields
from arcpy import metadata as md

# the output CSV file name
output_csv_file = 'enterprise_gdbs_results.csv'

# or use this to make the output CSV file name the same as the script name
# output_csv_file = os.path.basename(__file__).replace('.py','.csv')

# change this path to use your SDE connection files
sde_connection_files = 'c:/gis/sde_connection_files'

with open(output_csv_file,'w',newline='') as csv_file:
    csv_writer = csv.writer(csv_file, delimiter=',')
    column_headers = [
        'Geodatabase', 'Feature Dataset', 'Feature Class', 
        'Spatial Reference', 'Row Count', 'Column Count', 
        'Metadata Title', 'Metadata Description', 'Metadata Summary',
        'Metadata Credits', 'Metadata Access Constraints'
    ]
    
    csv_writer.writerow(column_headers)

    for (folder, dirs, files) in os.walk(sde_connection_files):
        for file in files:
            if(not file.startswith('_') and file.endswith('.sde')):
                geodatabase = file.split('@')[1]

                wksp = os.path.join(folder,file)
                env.workspace = wksp

                datasets = ListDatasets(feature_type='feature')
                datasets = [''] + datasets if datasets is not None else []

                for dataset in datasets:
                    for feature_class in ListFeatureClasses(dataset):
                        desc = Describe(feature_class)
                        spatial_reference = desc.SpatialReference.factoryCode
                        count = GetCount_management(feature_class)[0]
                        column_count = len(ListFields(feature_class))
                        metadata = md.Metadata(feature_class)

                        row = [
                            geodatabase,dataset,feature_class,
                            spatial_reference,count,column_count,
                            metadata.title,metadata.description,
                            metadata.summary,metadata.credits,
                            metadata.accessConstraints    
                        ]

                        print(row)
                        
                        csv_writer.writerow(row)

Enumerar todas las Geodatabases de Archivos y las Clases de Entidad y sus Metadatos

Este script es útil para auditar metadatos. La secuencia de comandos se puede ejecutar en varias geodatabases de archivos y creará un archivo CSV de salida con estas columnas: 'Última Modificación', 'Geodatabase de Archivos', 'Dataset de Entidades', 'Clase de Entidad', 'Referencia Espacial', 'Recuento de Filas', 'Recuento de Columnas', 'Título de Metadatos', 'Descripción de Metadatos', 'Resumen de Metadatos', 'Créditos de Metadatos', 'Restricciones de Acceso a Metadatos'.

import csv
import os
import time

from arcpy import Describe
from arcpy import env
from arcpy import GetCount_management
from arcpy import ListDatasets
from arcpy import ListFeatureClasses
from arcpy import ListFields
from arcpy import metadata as md

folder = r'...'
log = open('log.txt', 'w')
output_csv_file = os.path.basename(__file__).replace('.py','.csv')

with open(output_csv_file,'w',newline='') as csv_file:
    csv_writer = csv.writer(csv_file, delimiter=',')
    column_headers = [
        'Last Modified','File Geodatabase', 'Feature Dataset', 'Feature Class', 
        'Spatial Reference', 'Row Count', 'Column Count', 
        'Metadata Title', 'Metadata Description', 'Metadata Summary',
        'Metadata Credits', 'Metadata Access Constraints'
    ]
    
    csv_writer.writerow(column_headers)

    for (folder, dirs, files) in os.walk(folder):
        if(folder.endswith('.gdb')):
            print(folder)

            last_modified = '???'

            try:
                last_modified = time.ctime(max(os.stat(root).st_mtime for root,_,_ in os.walk(folder)))
            except:
                msg = 'Error getting last modified date for {}'.format(folder)
                print(msg)
                log.write('{}\n'.format(msg))
                pass

            fgdb = folder
            env.workspace = fgdb

            datasets = []

            try:
                datasets = ListDatasets(feature_type='feature')
                datasets = [''] + datasets if datasets is not None else []
            except:
                msg = 'Error getting datasets for {}'.format(folder)
                print(msg)
                log.write('{}\n'.format(msg))
                pass

            for dataset in datasets:
                for feature_class in ListFeatureClasses(dataset):
                    desc = Describe(feature_class)
                    spatial_reference = desc.SpatialReference.factoryCode
                    count = GetCount_management(feature_class)[0]
                    column_count = len(ListFields(feature_class))
                
                    metadata = None
                    row = []

                    try:
                        metadata = md.Metadata(feature_class)
                        row = [
                            last_modified,
                            fgdb,dataset,feature_class,
                            spatial_reference,count,column_count,
                            metadata.title,metadata.description,
                            metadata.summary,metadata.credits,
                            metadata.accessConstraints    
                        ]
                    except:
                        row = [
                            last_modified,
                            fgdb,dataset,feature_class,
                            spatial_reference,count,column_count,
                            'error','error','error','error','error'    
                        ]
                        pass

                    csv_writer.writerow(row)

log.close()

Eliminar Columnas Redundantes en las Clases de Entidad de Geodatabase de Archivos

A veces, cuando los datos se convierten de archivos de forma a clases de entidad o si no se ha tenido cuidado al ejecutar las herramientas de geoprocesamiento, las clases de entidad pueden terminar con campos redundantes. Por ejemplo, una clase de entidad podría tener un campo llamado "OBJECTID" y puede haber otro campo llamado "OBJECTID_1" en la misma clase de entidad. Uno de estos campos debe ser el campo OID para la clase de entidad, sin embargo, a veces tampoco está claro qué campo OBJECTID es el correcto. Esta secuencia de comandos a continuación no necesita saber qué campo es el campo OID porque la línea 35 fallará si el campo no se puede eliminar y la secuencia de comandos continuará ejecutándose. La siguiente secuencia de comandos muestra dos formas diferentes en que se puede verificar el nombre del campo, es decir, el nombre del campo se puede incluir en la lista en la línea 10 o el nombre del campo puede tener el prefijo "OBJECTID" en la línea 33. Para esta secuencia de comandos, los campos eliminados se envían a un archivo CSV. El nombre del archivo CSV de salida es el mismo nombre que el script de Python - consulte la línea 12. Antes de ejecutar el script, es una buena idea comentar la línea 35, ejecutar el script y verificar el archivo CSV de salida para ver qué campos será borrado. Además, una vez que se elimina el campo, no se puede recuperar, por lo que, en caso de duda, primero se debe hacer una copia de seguridad de las geodatabases de archivos.

import csv
import os

from arcpy import env
from arcpy import ListDatasets
from arcpy import ListFeatureClasses
from arcpy import ListFields
from arcpy.management import DeleteField

fields_to_delete = ['objectid', 'objectid_1', 'objectid_12', 'shape_le_1', 'shape_leng', 'shape_length', 'shape__length', 'shape__area']
input_folder = r'...'
output_csv_file = os.path.basename(__file__).replace('.py','.csv')

with open(output_csv_file, 'w', newline='') as csv_file:
    csv_writer = csv.writer(csv_file)
    csv_writer.writerow(['File Geodatabase','Feature Dataset', 'Feature Class', 'Field'])

    for (folder, dirs, files) in os.walk(input_folder):
        if(folder.endswith('.gdb')):
            file_geodatabase = folder
            print('Processing {}'.format(file_geodatabase))

            env.workspace = file_geodatabase

            feature_datasets = ListDatasets(feature_type='feature')
            feature_datasets = [''] + feature_datasets if feature_datasets is not None else []

            for feature_dataset in feature_datasets:
                feature_classes = ListFeatureClasses(feature_dataset=feature_dataset)

                for feature_class in feature_classes:
                    for field in ListFields(feature_class):
                        if field.name.lower() in fields_to_delete or field.name.lower().startswith('objectid'):
                            try:
                                DeleteField(feature_class, field.name)
                                csv_writer.writerow([file_geodatabase, feature_dataset, feature_class, field.name])
                            
                            except:
                                pass

Recalcular Extensiones de Clase de Entidad en Geodatabases de Archivos

Antes de publicar servicios de mapas o servicios de entidades, es una buena práctica recalcular primero la extensión de la clase de entidad. Esto se debe a que, en ocasiones, la extensión de la clase de entidad puede ser incorrecta. Hay varias cosas que pueden hacer que la extensión de la clase de entidad sea incorrecta, incluida la ejecución de tareas de geoprocesamiento en los datos que cambian la extensión de los datos y la extensión de la clase de entidad también puede ser incorrecta al importar datos porque la extensión de la clase de entidad inicial puede tener calculado en base a un subconjunto de los datos que se importaron. La primera manera fácil de ver que la extensión de la clase de entidad es incorrecta es al hacer clic en el botón de zoom a capa, el mapa no se acerca a la extensión correcta. Otra señal de que la extensión de la capa es incorrecta es que la capa no se procesa correctamente. Por ejemplo, al importar un archivo GeoJSON grande, es posible que no se represente correctamente en ArcGIS Pro hasta que se haya vuelto a calcular la extensión para esa clase de entidad.

import os

from arcpy import env
from arcpy import ListDatasets
from arcpy import ListFeatureClasses
from arcpy.management import RecalculateFeatureClassExtent

input_folder = r'...'

for (folder, dirs, files) in os.walk(input_folder):
    if(folder.endswith('.gdb')):
        env.workspace = folder

        feature_datasets = ListDatasets(feature_type='feature')
        feature_datasets = [''] + feature_datasets if feature_datasets is not None else []

        for feature_dataset in feature_datasets:
            feature_classes = ListFeatureClasses(feature_dataset=feature_dataset)

            for feature_class in feature_classes:
                print('{}\t{}\t{}'.format(folder, feature_dataset, feature_class))
                RecalculateFeatureClassExtent(feature_class)

Encontrar todos los Shapefiles en un Directorio y enviar la Lista a CSV

Este script es para enumerar todos los archivos de forma en un directorio para ayudar a comprender cuántos archivos de forma tiene, de modo que se puedan migrar a clases de entidad en geodatabases de archivos o geodatabases corporativas. Tenga en cuenta que los archivos de forma generalmente deben evitarse por varias razones. El formato de archivo de forma es un formato muy antiguo y existen formatos mucho mejores para compartir datos espaciales. Los archivos de forma tienen una compresión deficiente y cuando los datos se exportan a archivos de forma, los nombres de los campos se truncan a diez caracteres, lo que puede dificultar adivinar cuál era el nombre del campo original. Utilice clases de entidad de geodatabase, geopaquetes, geojson u otros formatos antes de considerar el uso de archivos de forma.

import csv
import os

# change the input folder here for the directory you want to search
input_folder = r'\\...\...'

# change the file name here to the output file you want
results_file = 'shapefiles.csv'

extns = ['.aih', '.ain', '.atx', '.cpg', '.dbf', '.fbn', '.fbx', '.ixs', '.mxs', '.prj', '.sbn', '.sbx', '.shp', '.shx', '.xml']

with open(results_file, 'w', newline='') as csvfile:
    csvwriter = csv.writer(csvfile)
    column_headers = ['Folder','Shapefile'] + extns
    csvwriter.writerow(column_headers)

    for (folder, dirs, files) in os.walk(input_folder):
        for file in files:
            if(file.endswith('.shp')):
                shapefile_name = file.replace('.shp','')

                line = [folder,shapefile_name]

                for extn in extns:
                    file_path = os.path.join(folder,'{}{}'.format(shapefile_name,extn))
                    file_exists = 'Y' if os.path.exists(file_path) else 'N'
                    line.append(file_exists)
                
                csvwriter.writerow(line)

Enumerar todos los archivos ArcGIS Pro APRX y ArcMap MXD y su información de capa

Este script enumera la información de capa para MXD (archivos de ArcMap) y APRX (archivos de ArcGIS Pro). Los resultados se envían a un archivo CSV y contienen estas columnas:

Ruta del Archivo: la ruta completa del archivo para MXD o APRX
Carpeta: la carpeta en la que se encuentra el MXD o APRX
Nombre del Archivo: el nombre del archivo del MXD o APRX
Tipo de Archivo: MXD o APRX
Mapa / Marco de Datos: en APRX, un "mapa" equivale a un "marco de datos" de MXD
Nombre de Capa: el nombre de la capa
Fuente de Capa: la fuente de datos de la capa
Está Rota: el MXD o APRX aún pueden ver la fuente de datos original
Consulta de Definición: la capa tiene un filtro SQL

Tenga en cuenta que ArcMap usa Python 2 y ArcGIS Pro usa Python 3, así que para que la secuencia de comandos funcione con Python 3 para archivos MXD, convertimos el MXD en un APRX en la secuencia de comandos a continuación. Este APRX solo está en la memoria y no se guardará en el disco (pero se puede guardar en el disco si es necesario).

Para ejecutar esto, cambie las líneas 5 y 7 y cree manualmente un APRX en blanco que se pueda clonar en la memoria (línea 7).

import csv
import os

from arcpy.mp import ArcGISProject

directory = r'\\...\...'
blank_aprx = r'\\...\...\temp.aprx'
results_file = os.path.basename(__file__).replace('.py','.csv')

# create a CSV file
with open(results_file, 'w', newline='') as csvfile:
    csvwriter = csv.writer(csvfile)

    # write out the column headers in the CSV file
    csvwriter.writerow(['File Path','Folder','File Name','File Type','Map / Data Frame','Layer Name','Layer Source','Is Broken','Definition Query'])

    # loop through all of the folders and files in the input directory
    for folder, dirs, files in os.walk(directory):
        for file in files:
            file_path = os.path.join(folder,file)
            
            # check if it is an MXD file - we need to convert the MXD to APRX (in-memory) because we cannot use Python 3 with MXDs
            if file.endswith('.mxd'):     
                file_type = 'mxd'
                aprx = ArcGISProject(blank_aprx)
                aprx.importDocument(file_path)

            #  check if it is an APRX file
            elif file.endswith('.aprx'):
                file_type = 'aprx'
                aprx = ArcGISProject(file_path)
            
            else:
                # file is not an MXD or APRX, so skip the loop below
                continue

            # list all layers within the 'maps' (for APRXs), or 'data frames' (for MXDs)
            for map in aprx.listMaps():
                for layer in map.listLayers():
                    # if the layer is not a group layer and has a data source
                    if layer.supports('dataSource'):
                        # check if the layer is broken
                        isBroken = layer.isBroken if layer.supports('isBroken') else 'n/a'
                        # check if the layer has a definition query (the WHERE clause in a normal SQL statement - definition queries use SQL)
                        definitionQuery = layer.definitionQuery if layer.supports('definitionQuery') else 'n/a'
                        line = [file_path, folder, file, file_type, map.name, layer.name, layer.dataSource, isBroken, definitionQuery]

                        # write the results to CSV
                        csvwriter.writerow(line)

            # delete the in-memory aprx
            del aprx

print('Results file: {}'.format(results_file))

Mostrar Información del Servicio de Mapas de ArcGIS Server

Este script enumera la información del servicio para todos los servicios y genera los resultados en CSV. Los encabezados de columna en el CSV se enumeran a continuación:

Servidor de Mapas
Carpeta
Nombre del Servicio
Tipo de Servicio
URL
Publicado Por
Ruta
Descripción del Servicio
Informacion Registrada

Antes de ejecutar el script, cambie los parámetros de Líneas 22 a 31.

import csv
import json
import requests

def getToken(url, params):
    response = requests.post(url, params)
    token = json.loads(response.text)['token']
    return token

def fetchUrl(url):
    params = {
        'f': 'json',
        'token': token
    }

    response = requests.post(url, params)
    data = json.loads(response.text)

    return data

web_adaptor = 'arcgis' # web adaptor or load balancer 
token_url = 'https://{}/portal/sharing/rest/generateToken'.format(map_server)

params = {
    'f': 'json',
    'referer': 'https://.../portal/sharing/rest/generateToken',
    'username': 'portaladmin',
    'password': '**************'
}

token = getToken(token_url, params)

''' 
    ArcGIS Admin URL - we are using the admin URL, not the 
    Services Directory URL because the Services Directory will 
    only list the services that are started/running.  We also
    want to know about the stopped services.
'''
admin_url = 'https://{}/{}/admin/services'.format(map_server,web_adaptor)

params = {
    'f': 'json',
    'token': token
}

response = requests.get(admin_url, params)
data = json.loads(response.text)

folders = data['folders']
foldersToExclude = ['System','Utilities']

for folder in foldersToExclude:
    folders.remove(folder)

services = data['services'] 

with open('map_service_info.csv', 'w', newline='') as csv_file:
    csv_writer = csv.writer(csv_file)

    column_names = ['Map Server', 'Folder', 'Service name', 'Service type', 'URL', 'Published By', 'Path', 'Service Description', 'Copyright Info']
    csv_writer.writerow(column_names)

    for service in services:
        folder = ''
        service_name = service['serviceName']
        service_type = service['type']
        url = '{}/{}.{}'.format(admin_url,service_name,service_type)
       
        service_info = fetchUrl(url)
        service_description = service_info['description']
        user_name = service_info['properties']['userName'] if 'userName' in service_info['properties'] else ''
        copyright_info = service_info['properties']['copyright'] if 'copyright' in service_info['properties'] else ''
        path = service_info['properties']['path'] if 'path' in service_info['properties'] else ''

        row = [map_server, folder, service_name, service_type, url, user_name, path, service_description, copyright_info]
        csv_writer.writerow(row)

    for folder in folders:
        url = '{}/{}'.format(admin_url,folder)
        folder_info = fetchUrl(url)

        for service in folder_info['services']:
            folder = folder_info['folderName']
            service_name = service['serviceName']
            service_type = service['type']
            url = '{}/{}/{}.{}'.format(admin_url, folder, service_name, service_type, url)

            service_info = fetchUrl(url)
            service_description = service_info['description']
            user_name = service_info['properties']['userName'] if 'userName' in service_info['properties'] else ''
            copyright_info = service_info['properties']['copyright'] if 'copyright' in service_info['properties'] else ''
            path = service_info['properties']['path'] if 'path' in service_info['properties'] else ''

            row = [map_server, folder, service_name, service_type, url, user_name, path, service_description, copyright_info]
            csv_writer.writerow(row)