def is_arc_licensed():
try:
import arcpy
except RuntimeError:
print "arc not licensed"
return False
else:
print "arc is licensed for " + arcpy.ProductInfo()
return not arcpy.ProductInfo() == "NotInitialized"
def validateLicense():
"""
Check that the current license is using advanced.
:return:
"""
if not arcpy.ProductInfo() == 'ArcInfo':
if arcpy.CheckProduct('ArcInfo') == 'available':
arcpy.SetProduct('ArcInfo')
else:
raise Exception('An advanced license was not available')
def checkout(name):
try:
if name == Products.ARCINFO: import arcinfo
if name == Products.ARCEDITOR: import arceditor
if name == Products.ARCVIEW: import arcview
import archook
archook.get_arcpy()
import arcpy
return arcpy if arcpy.ProductInfo() != "NotInitialized" else None
except Exception as e:
logging.debug(e)
return None
def execute(self, parameters, messages):
inFeatures = parameters[0].valueAsText
outFeatures = parameters[1].valueAsText
geometryType = parameters[2].valueAsText
if (not geometryType):
geometryType = "ENVELOPE"
# arcinfo user use [MinimumBoundingGeometry_management]
if (arcpy.ProductInfo() != "ArcInfo" or geometryType != "CONVEX_HULL"):
arcpy.MinimumBoundingGeometry_management(inFeatures,
outFeatures,
geometryType)
return
# only CONVEX_HULL
inDesc = arcpy.Describe(inFeatures)
if (inDesc.dataType == "FeatureLayer"):
inDesc = inDesc.featureClass
dirName, fcName = os.path.split(outFeatures)
#create output
arcpy.CreateFeatureclass_management(dirName, fcName, "POLYGON", inFeatures, "SAME_AS_TEMPLATE", "SAME_AS_TEMPLATE", inDesc.spatialReference)
fields = arcpy.ListFields(outFeatures)
fieldList = []
for field in fields:
#messages.addMessage("{0} is a type of {1} with a length of {2}"
# .format(field.name, field.type, field.length))
if (field.type != "OID" or field.type != "Geometry" ):
fieldList.append(field.name)
fieldList.append("SHAPE@")
# for Progress step count
result = arcpy.GetCount_management(inFeatures)
count = int(result.getOutput(0))
arcpy.SetProgressor("step", "Inserting ...", 0, count, 1)
with arcpy.da.InsertCursor(outFeatures, fieldList) as inCursor:
with arcpy.da.SearchCursor(inFeatures, fieldList) as cursor:
for row in cursor:
if (isinstance(row[-1] , arcpy.Polygon)):
insertRow = row[:-1] + (row[-1].convexHull(),)
inCursor.insertRow( insertRow )
#step count
arcpy.SetProgressorPosition()
def createConnFile(self):
'''
Turns out this is actually much simpler than was originally
thought. Don't need a schema or a password to create the
the sde file. This makes things much simpler
'''
# connFileFullPath = self.secrets.getConnectionFilePath()
connDirPath, connFilePath = os.path.split(self.connFile2Create)
self.logger.debug("connDir: %s", connDirPath)
self.logger.debug("connFile: %s", connFilePath)
self.logger.debug("Connection file: %s", self.connFile2Create)
suffix = os.path.splitext(self.connFile2Create)[1]
if not suffix:
self.connFile2Create = '{0}.sde'.format(self.connFile2Create)
if not os.path.exists(self.connFile2Create):
# if not arcpy.Exists(connFileFullPath):
self.logger.debug('trying to create conn file ...')
# for direct connect use:
# CreateDatabaseConnection_management
# host:port/serviceName, most of the time its just host/serviceName
connStr = self.getConnectionString()
self.logger.debug("importing arcpy...")
import arcpy # @UnresolvedImport
self.logger.debug("arcpy imported")
arcpy.SetProduct('arcinfo')
self.logger.debug('arcpy product info %s', arcpy.ProductInfo())
self.logger.debug("arcpytool report: %s",
arcpy.CreateDatabaseConnection_management)
self.logger.debug(
'inspect %s',
inspect.getargspec(arcpy.CreateDatabaseConnection_management))
# seems to require a value for username and password even through they are invalid
arcpy.CreateDatabaseConnection_management(connDirPath,
connFilePath,
self.dbtype.upper(),
connStr, 'DATABASE_AUTH',
'junk', 'junk',
'DO_NOT_SAVE_USERNAME',
self.sde)
self.logger.info('connection file %s has been created',
self.connFile2Create)
def setup_arcpyenvironment():
'''
Setup the ArcPy stuff, required for
to run ArcMap jobs in Python.
ArcPy requires us to setup an environment.
:return:
'''
# Prepare the ArcGIS environment
arcpy.AddMessage(arcpy.ProductInfo())
arcpy.CheckOutExtension("Spatial")
arcpy.env.parallelProcessingFactor = "100%"
# Setup workspace and project management:
arcpy.env.workspace = "in_memory"
arcpy.env.overwriteOutput = True
def send_msg(message, messagetype="message"):
""" output messages to stdout as well as arcpy """
if messagetype.lower() == "message":
arcpy.AddMessage(message)
if messagetype.lower() == "warning":
arcpy.AddWarning(message)
if messagetype.lower() == "error":
if arcpy.ProductInfo() != "ArcServer":
arcpy.AddError("Failed. " + message)
else:
arcpy.AddMessage("Failed. " + message)
# set the result_output parameter
arcpy.SetParameterAsText(20, ("Failed. " + message))
if messagetype.lower() == "success":
# set the result_output parameter in case of success
arcpy.AddMessage("Success. " + message)
arcpy.SetParameterAsText(20, ("Success. " + message))
print(message)
def validate_user_table(userTableDescribe):
""" validates user table schema requirements """
# do these checks only when run in desktop while publishing
# this check is not required on server after publishing as gp service
if arcpy.ProductInfo() == "ArcServer":
return True
#Commented out to shave .05 seconds off
#if not arcpy.Exists(user_table):
#send_msg("User table does not exist", "error")
#return False
# check if user table has globalid enabled
if not userTableDescribe.hasGlobalID:
send_msg("User table does not have globalids enabled.", "error")
return False
upperPath = userTableDescribe.path.upper()
if ('.SDE' in upperPath or '.GDS' in upperPath):
return True
return False
def validate_user_table():
""" validates user table schema requirements """
# do these checks only when run in desktop while publishing
# this check is not required on server after publishing as gp service
if arcpy.ProductInfo() == "ArcServer":
return True
desc = arcpy.Describe(user_table)
# check if user table has globalid enabled
if not desc.hasGlobalID:
send_msg("User table does not have globalids enabled.", "error")
return False
# check if user table is an enterprise gdb
workspace_props = arcpy.Describe(desc.path)
if workspace_props.workspaceFactoryProgID == "esriDataSourcesGDB.SdeWorkspaceFactory.1":
return True
else:
send_msg("User table must be sourced from an enterprise geodatabase",
"error")
return False
def CreateDefaultKeys(InDB):
#add default keys to the upc_key table
fields = ['KeyName','KeyValue']
cur = arcpy.da.InsertCursor(os.path.join(InDB,'upc_key'),fields)
cur.insertRow(('BaseGeom_bnd','add a base geometry'))
cur.insertRow(('BaseGeom_cent','add a base geometry'))
cur.insertRow(('BaseGeom_id','add a base geometry'))
# cur.insertRow(('Subarea_bnd',UPConfig['Subarea_bnd']))
# cur.insertRow(('Subarea_id',UPConfig['Subarea_id']))
# cur.insertRow(('Subarea_search',UPConfig['Subarea_search']))
if arcpy.ProductInfo() == 'ArcInfo':
cur.insertRow(('DistMode','GenerateNear'))
else:
cur.insertRow(('DistMode','RasterEuc'))
# if 'Redev' in UPConfig.keys():
# cur.insertRow(('Redev',UPConfig['Redev']))
# cur.insertRow(('Redev_pop',UPConfig['Redev_pop']))
# cur.insertRow(('Redev_emp',UPConfig['Redev_emp']))
del cur
def validate_inputs():
""" validate and initialize user table """
# this check is not required on server after publishing as gp service
if arcpy.ProductInfo() != "ArcServer":
desc = arcpy.Describe(user_table)
# check if user table has globalid enabled
if not desc.hasGlobalID:
send_msg("User table does not have globalids enabled.", "error")
return False
# check if user table is an enterprise gdb
workspace_props = arcpy.Describe(desc.path)
if workspace_props.workspaceFactoryProgID not in [
"esriDataSourcesGDB.SdeWorkspaceFactory.1",
"esriDataSourcesGDB.SdeWorkspaceFactory"
]:
send_msg(
"User table must be sourced from an enterprise geodatabase",
"error")
return False
# check if test login email exists
if test_mode == "true":
send_msg("=" * 30)
send_msg("TEST MODE")
send_msg("-" * 30)
whereclause = "UPPER({0})='{1}'".format(user_email_field,
test_login_email.upper())
rowcount = 0
with arcpy.da.SearchCursor(in_table=user_table,
field_names=[user_email_field],
where_clause=whereclause) as cursor:
rowcount = len([i for i in cursor])
if rowcount == 0:
send_msg("Test login email does not exist.", "error")
return False
elif rowcount == 1:
return True
else:
return True
def send_msg(
message,
messagetype="message",
):
""" output messages to stdout as well as arcpy """
if messagetype.lower() == "message":
arcpy.AddMessage(message)
if messagetype.lower() == "warning":
arcpy.AddWarning(message)
if messagetype.lower() == "error":
if arcpy.ProductInfo() != "ArcServer":
arcpy.AddError("Failed. " + message)
else:
arcpy.AddMessage("Failed. " + message)
# set the result_output parameter
out_message = {"status": "Failed", "description": message}
arcpy.SetParameterAsText(28, out_message)
if messagetype.lower() == "success":
# set the result_output parameter in case of success
out_message = {"status": "Success", "description": message}
arcpy.SetParameterAsText(28, out_message)
print(message)
def createSDE(database_type, instance, database, account_authentication,
dbms_admin, dbms_admin_pwd, schema_type, gdb_admin,
gdb_admin_pwd, tablespace, license):
# Get the current product license
product_license = arcpy.ProductInfo()
# Checks required license level
if product_license.upper() == "ARCVIEW" or product_license.upper(
) == 'ENGINE':
print(
"\n" + product_license + " license found!" +
" Creating an enterprise geodatabase requires an ArcGIS for Desktop Standard or Advanced, ArcGIS Engine with the Geodatabase Update extension, or ArcGIS for Server license."
)
sys.exit("Re-authorize ArcGIS before creating enterprise geodatabase.")
else:
print("\n" + product_license +
" license available! Continuing to create...")
arcpy.AddMessage("++++++++++++++++++")
try:
arcpy.AddMessage("Creating enterprise geodatabase...")
arcpy.CreateEnterpriseGeodatabase_management(
database_platform=database_type,
instance_name=instance,
database_name=database,
account_authentication=account_authentication,
database_admin=dbms_admin,
database_admin_password=dbms_admin_pwd,
sde_schema=schema_type,
gdb_admin_name=gdb_admin,
gdb_admin_password=gdb_admin_pwd,
tablespace_name=tablespace,
authorization_file=license)
for i in range(arcpy.GetMessageCount()):
arcpy.AddReturnMessage(i)
arcpy.AddMessage("++++++++++++++++++")
except:
for i in range(arcpy.GetMessageCount()):
arcpy.AddReturnMessage(i)
def hasLicense(*licenses):
"""Is the required license in use?"""
return arcpy.ProductInfo() in licenses
def ImportBaseGeom(UPlanGDB, InSHP, DescName, CentInside):
'''
*Imports a Base Geometry layer to the GDB
*Adds a field called up_polyid and calculates it equal to the ObjectID
*Creates a Centroid layer from the Base Geometry layer and names it BaseGeom_cent
*Adds a record to the upc_layers table for this Base Geometry layer and the centroid layer
*updates the upc_keys table with the new base geometry info
*updates pickle file
Calls:
AddToUPC_Layers
Called by:
The Import Base Geometry Toolbox
Arguments:
UPlanGDB: The UPlan GDB (where the layer will be imported)
InSHP: The shapefile to import
DescName: The descriptive name of the layer
CentInsdie = True if you want to force the centroid inside of the polygons, false for true centroid
Returns: None
'''
arcpy.env.workspace = UPlanGDB
arcpy.env.overwriteOutput = True
#Register it with the layer tracker
if os.path.basename(InSHP)[-4:] == ".shp":
SHPName = os.path.basename(InSHP)[:-4]
#if the shp has a field named "OBJECTID", it needs to be deleted
#(SHPs use FID, so if OBJECT ID is there, it's from copying form a GDB
#when copied back into the UPlan GDB it creates OBJECTID_1 instead of OBJECTID if OBJECTID isn't deleted)
if FieldExist(InSHP, 'OBJECTID'):
arcpy.DeleteField_management(InSHP, 'OBJECTID')
else:
SHPName = os.path.basename(InSHP)
AddToUPC_Layers(UPlanGDB, SHPName, DescName, 'BaseGeom_bnd')
#delete up_polyid field if it exists
if FieldExist(InSHP, 'up_polyid'):
arcpy.DeleteField_management(InSHP, 'up_polyid')
#Import the shp to the GDB
arcpy.FeatureClassToFeatureClass_conversion(InSHP, UPlanGDB, SHPName)
#Add int field called "up_polyid" and calc = to object ID
arcpy.AddField_management(SHPName, "up_polyid", "LONG")
arcpy.CalculateField_management(SHPName, "up_polyid", "!OBJECTID!",
"PYTHON_9.3")
#Create centroid layer and drop all fields except for "up_polyid" (and shape and objectid).
if arcpy.ProductInfo() == 'ArcInfo':
if CentInside:
CentType = 'INSIDE'
else:
CentType = 'CENTROID'
arcpy.FeatureToPoint_management(SHPName, "poly_cent", CentType)
else:
CreateCentroids(UPlanGDB, SHPName)
Fields = arcpy.ListFields("poly_cent")
FieldList = []
for Field in Fields:
if not Field.required:
if not Field.name == "up_polyid":
FieldList.append(Field.name)
arcpy.DeleteField_management("poly_cent", FieldList)
#add centroid layer to layer tracker table
AddToUPC_Layers(UPlanGDB, 'poly_cent',
'Base Geometry Centroids (Created from: ' + SHPName + ')',
'BaseGeom_cent')
#update upc_key table with base geometry info
UpdateUPCKeyTable(UPlanGDB, 'BaseGeom_bnd', SHPName)
UpdateUPCKeyTable(UPlanGDB, 'BaseGeom_cent', 'poly_cent')
UpdateUPCKeyTable(UPlanGDB, 'BaseGeom_id', 'up_polyid')
#update pickle file
DBSplit = uiut.SplitPath(UPlanGDB)
UPConfig = {}
UPConfig = upc.ReadUPConfigFromGDB(DBSplit[0], DBSplit[1])
uiut.MakePickle(UPConfig, UPlanGDB)
def export_map_document(product_location,
mxd,
map_doc_name,
data_frame,
outputdirectory,
export_type,
production_xml=None):
"""Exports MXD to chosen file type"""
try:
export = export_type.upper()
product = arcpy.ProductInfo()
arcpy.AddMessage("Product: " + product)
if product == 'ArcServer':
filename_prefixe = "_ags_"
else:
filename_prefixe = ""
if export == "PDF":
filename = filename_prefixe + map_doc_name + ".pdf"
outfile = os.path.join(outputdirectory, filename)
# Export to PDF optional parameters
data_frame = "PAGE_LAYOUT"
df_export_width = 640
df_export_height = 480
resolution = 300
image_quality = "BEST"
colorspace = "RGB"
compress_vectors = True
image_compression = "ADAPTIVE"
picture_symbol = "RASTERIZE_BITMAP"
convert_markers = False
embed_fonts = True
layers_attributes = "LAYERS_ONLY"
georef_info = True
jpeg_compression_quality = 80
# Run the export tool
arcpy.mapping.ExportToPDF(mxd, outfile, data_frame,
df_export_width, df_export_height,
resolution, image_quality, colorspace,
compress_vectors, image_compression,
picture_symbol, convert_markers,
embed_fonts, layers_attributes,
georef_info, jpeg_compression_quality)
arcpy.AddMessage("PDF is located: " + outfile)
arcpy.AddMessage(filename)
return filename
elif export == 'JPEG':
filename = filename_prefixe + map_doc_name + ".jpg"
outfile = os.path.join(outputdirectory, filename)
# Export to JEPG optional parameters
data_frame = "PAGE_LAYOUT"
df_export_width = 640
df_export_height = 480
resolution = 96
world_file = False
color_mode = "24-BIT_TRUE_COLOR"
jpeg_quality = 100
progressive = False
# Run the export tool
arcpy.mapping.ExportToJPEG(mxd, outfile, data_frame,
df_export_width, df_export_height,
resolution, world_file, color_mode,
jpeg_quality, progressive)
arcpy.AddMessage("JPEG is located: " + outfile)
return filename
elif export == 'TIFF':
filename = filename_prefixe + map_doc_name + ".tif"
outfile = os.path.join(outputdirectory, filename)
# Export to JPEG optional parameters
data_frame = "PAGE_LAYOUT"
df_export_width = 640
df_export_height = 480
resolution = 96
world_file = False
color_mode = "24-BIT_TRUE_COLOR"
tiff_compression = "LZW"
# Run the export tool
arcpy.mapping.ExportToTIFF(mxd, outfile, data_frame,
df_export_width, df_export_height,
resolution, world_file, color_mode,
tiff_compression)
arcpy.AddMessage("TIFF is located: " + outfile)
return filename
elif export == "MAP PACKAGE":
filename = filename_prefixe + map_doc_name + ".mpk"
outfile = os.path.join(outputdirectory, filename)
dfextent = data_frame.extent
mxd = mxd.filePath
arcpy.AddMessage(mxd)
# Export to MPK optional parameters
convert_data = "CONVERT"
convert_arcsde_data = "CONVERT_ARCSDE"
apply_extent_to_arcsde = "ALL"
arcgisruntime = "DESKTOP"
reference_all_data = "NOT_REFERENCED"
version = "ALL"
# Run the export tool
arcpy.PackageMap_management(mxd, outfile, convert_data,
convert_arcsde_data, dfextent,
apply_extent_to_arcsde, arcgisruntime,
reference_all_data, version)
arcpy.AddMessage("MPK is located: " + outfile)
return filename
elif export == 'LAYOUT GEOTIFF':
filename = filename_prefixe + map_doc_name + ".tif"
outfile = os.path.join(outputdirectory, filename)
# Export to Layout GeoTIFF optional parameters:
resolution = 96
world_file = False
color_mode = "24-BIT_TRUE_COLOR"
tiff_compression = "LZW"
# Run the export tool
arcpyproduction.mapping.ExportToLayoutGeoTIFF(
mxd, outfile, data_frame, resolution, world_file, color_mode,
tiff_compression)
arcpy.AddMessage("Layout GeoTIFF is located: " + outfile)
return filename
elif export == 'PRODUCTION PDF' or export == 'MULTI-PAGE PDF':
filename = filename_prefixe + map_doc_name + ".pdf"
outfile = os.path.join(outputdirectory, filename)
setting_file = os.path.join(product_location, production_xml)
if os.path.exists(setting_file) == True:
arcpyproduction.mapping.ExportToProductionPDF(
mxd, outfile, setting_file)
arcpy.AddMessage("Production PDF is located: " + outfile)
else:
arcpy.AddMessage(
"Production PDF is the default exporter for a Multi-page PDF."
)
arcpy.AddWarning(
"Color mapping rules file doesn't exist, using "
"standard ExportToPDF exporter with default "
"settings.")
arcpy.mapping.ExportToPDF(mxd, outfile)
arcpy.AddMessage("PDF is located: " + outfile)
return filename
else:
arcpy.AddError("The exporter : " + export + " is not supported, "
"please contact your system administrator.")
except arcpy.ExecuteError:
arcpy.AddError(arcpy.GetMessages(2))
except Exception as ex:
arcpy.AddError(ex.message)
tb = sys.exc_info()[2]
tbinfo = traceback.format_tb(tb)[0]
arcpy.AddError("Traceback info:\n" + tbinfo)
class CustomError(Exception):
pass
try:
# Get the original overwrite output setting so we can reset it at the end.
OverwriteOutput = arcpy.env.overwriteOutput
# It's okay to overwrite stuff in this tool
arcpy.env.overwriteOutput = True
# Check if they have the necessary license.
# The snap_edit tool requires at least Standard (ArcEditor)
ArcLicense = arcpy.ProductInfo()
if ArcLicense != "ArcEditor" and ArcLicense != "ArcInfo":
message = "To run this tool, you must have the Desktop Standard (ArcEditor) \
or Advanced (ArcInfo) license. Your license type is: %s." % ArcLicense
arcpy.AddError(message)
raise CustomError
# ----- Collect user inputs -----
# Location of FD where network dataset will be created
outFD = arcpy.GetParameterAsText(0)
# Streets feature class
Streets = arcpy.GetParameterAsText(1)
# SQL expression for selecting street features where pedestrians are allowed
SelectExpression = arcpy.GetParameterAsText(2)
# Max distance for which stops will be snapped to streets
import arcpy
licensed = arcpy.ProductInfo()
if licensed == 'ArcInfo':
testfile = open('C:\Program Files (x86)\ArcGIS\Desktop10.6\licensed','w')
testfile.write(licensed)
testfile.close()
import arcpy
from arcpy import env
env.workspace = "C:/EsriPress/Python/Data/Exercise05"
in_features = "parks.shp"
out_featureclass = "Results/park_centroid.shp"
if arcpy.ProductInfo() == "ArcInfo":
arcpy.FeatureToPoint_management(in_features, out_featureclass)
else:
print "An ArcInfo license is not available"
#import arcview #import arceditor import arcinfo import arcpy print(arcpy.ProductInfo()) # prints ArcView, ArcEditor or ArcInfo
def checkCoverage(maskA, maskB, inputFile=None):
# Checks the coverage between polygons mask A and mask B
# Set temporary variables
prefix = os.path.join(arcpy.env.scratchGDB, "cover_")
maskACopy = prefix + "maskACopy"
maskBCopy = prefix + "maskBCopy"
maskACoverage = prefix + "maskACoverage"
# Copy maskA and maskBCopy to temporary variables
arcpy.CopyFeatures_management(maskA, maskACopy)
arcpy.CopyFeatures_management(maskB, maskBCopy)
percOut = 0
if checkLicenceLevel('Advanced') or arcpy.ProductInfo() == "ArcServer":
# Check if the fields Area_ha exist in maskACopy and maskBCopy
# If they do, delete them
maskAFields = arcpy.ListFields(maskACopy)
for field in maskAFields:
if field.name == "Area_ha":
arcpy.DeleteField_management(maskACopy, "Area_ha")
maskBFields = arcpy.ListFields(maskBCopy)
for field in maskBFields:
if field.name == "Area_ha":
arcpy.DeleteField_management(maskBCopy, "Area_ha")
# Delete fields area_ha in in maskACopy and maskBCopy
# Calculate total area of the coverage (study area or contributing area)
arcpy.AddField_management(maskBCopy, "Area_ha", "DOUBLE")
exp = "!SHAPE.AREA@HECTARES!"
arcpy.CalculateField_management(maskBCopy, "Area_ha", exp,
"PYTHON_9.3")
maskBCopyVal = 0
for row in arcpy.da.SearchCursor(maskBCopy, ["Area_ha"]):
maskBCopyVal += float(row[0])
# Use symmetrical difference to find which areas in maskA and maskBCopyCopy do not overlap
arcpy.SymDiff_analysis(maskACopy, maskBCopy, maskACoverage)
# Check if there are non-overlapping areas in the land use and coverage
rows = [row for row in arcpy.da.SearchCursor(maskACoverage, "*")]
numFeatures = len(rows)
if numFeatures != 0: # There is a discrepancy between mask A and mask B
# Calculate the area of the polygons in the discrepancy
arcpy.AddField_management(maskACoverage, "Sliver", "DOUBLE")
exp = "!SHAPE.AREA@HECTARES!"
arcpy.CalculateField_management(maskACoverage, "Sliver", exp,
"PYTHON_9.3")
area = 0
for row in arcpy.da.SearchCursor(maskACoverage, ["Sliver"]):
area += float(row[0])
# Calculate percentage of the coverage area that the discrepancy covers
percOut = float(area) / float(maskBCopyVal) * 100.0
if percOut > 2.5:
warning = 'Input data coverage is less tha 97.5 percent of the study area'
log.warning(warning)
warning = 'This may cause discrepancies in later calculations'
log.warning(warning)
warning = 'Please check this input: ' + str(inputFile)
log.warning(warning)
# Delete temporary masks
arcpy.Delete_management(maskACopy)
arcpy.Delete_management(maskBCopy)
arcpy.Delete_management(maskACoverage)
else:
log.warning(
'Coverage discrepancies between soil, land use, and coverage extent not checked as advanced license not present.'
)
log.warning(
'Please ensure the soil and land use shapefile cover at least 97.5 percent of the coverage extent'
)
def NearByGroup(in_features, group_fields, near_features, search_radius=""):
# Error if sufficient license is not available
if arcpy.ProductInfo().lower() not in ['arcinfo']:
arcpy.AddError("An ArcGIS for Desktop Advanced license is required.")
sys.exit()
# Read field values from input features
uniq_values = set()
scur = arcpy.SearchCursor(in_features, "", "", ";".join(group_fields))
try:
for row in scur:
value = tuple()
for field in group_fields:
value += (row.getValue(field),)
uniq_values.add(value)
except:""
finally:
if scur:
del scur
# Add fields to Input
arcpy.management.AddField(in_features, "NEAR_OID", "LONG")
arcpy.management.AddField(in_features, "NEAR_DISTN", "DOUBLE")
arcpy.management.AddField(in_features, "NEAR_FCLS", "TEXT")
# Make a selection based on the values
arcpy.management.MakeFeatureLayer(in_features, "input_lyr")
near_features_list = []
for each in near_features:
arcpy.management.MakeFeatureLayer(each, "{0}_lyr".format(os.path.splitext(os.path.basename(each))[0]))
near_features_list.append("{0}_lyr".format(os.path.splitext(os.path.basename(each))[0]))
# Set the progress bar
arcpy.SetProgressor("step", "Processing...", 0, len(uniq_values), 1)
for uniq_value in uniq_values:
expr = ""
for combo in zip(uniq_value, group_fields):
val = "'{0}'".format(combo[0]) if type(combo[0]) == str or type(combo[0]) == unicode else combo[0]
expr += """{0} = {1} AND """.format(combo[1], val)
expr = expr[:-5]
# Select the input features
arcpy.management.SelectLayerByAttribute("input_lyr", "", expr)
for each in near_features_list:
arcpy.management.SelectLayerByAttribute(each, "", expr)
# Run the Near process
arcpy.analysis.Near("input_lyr", near_features_list, search_radius)
# Calculate the values into the NEAR_FID and NEAR_DISTN fields
arcpy.management.CalculateField("input_lyr", "NEAR_OID", "!NEAR_FID!", "PYTHON")
arcpy.management.CalculateField("input_lyr", "NEAR_DISTN", "!NEAR_DIST!", "PYTHON")
if len(near_features) > 1:
arcpy.management.CalculateField("input_lyr", "NEAR_FCLS", """getpath(!NEAR_FC!)""", "PYTHON", """def getpath(layer):\n try:\n return arcpy.Describe(str(layer)).catalogPath\n except:\n return 'None'""")
else:
arcpy.management.CalculateField("input_lyr", "NEAR_FCLS", """r'{0}'""".format(arcpy.Describe(near_features[0]).catalogPath), "PYTHON")
arcpy.SetProgressorPosition()
# Clean up
arcpy.management.DeleteField("input_lyr", "NEAR_FID;NEAR_DIST;NEAR_FC")
for each in ["input_lyr"] + near_features_list:
try:
arcpy.management.Delete(each)
except:
""
arcpy.GetMessages(2)
except Exception as e:
arcpy.AddMessage(e.args[0])
## except ineditsessionerror:
## arcpy.AddMessage("You may not be in an editing session while this tool is active")
## arcpy.AddMessage("Please discontinue the edit session before operating this tool")
# End do_analysis function
# This test allows the script to be used from the operating
# system command prompt (stand-alone), in a Python IDE,
# as a geoprocessing script tool, or as a module imported in
# another script
if __name__ == '__main__':
# Arguments are optional
argv = tuple(
arcpy.GetParameterAsText(i) for i in range(arcpy.GetArgumentCount()))
if arcpy.CheckProduct(
"ArcEditor") == "AlreadyInitialized" or arcpy.CheckProduct(
"ArcInfo") == "AlreadyInitialized":
arcpy.AddMessage("Current License Level: " + arcpy.ProductInfo())
do_analysis(*argv)
else:
arcpy.AddMessage("Current License Level: " + arcpy.ProductInfo())
arcpy.AddMessage(
"Error: ArcEditor (ArcGIS for Desktop Standard) or ArcInfo (ArcGIS for Desktop Advanced) Required"
)
arcpy.AddMessage("Program Terminated")
### Version check
##version = str(arcpy.GetInstallInfo()['Version'])
##if version.find("10.") > 0:
## ArcGIS10 = True
##else:
## ArcGIS10 = False
#### Convert version string to a float value (needed for numeric comparison)
##versionFlt = float(version[0:4])
##if versionFlt < 10.5:
## arcpy.AddError("\nThis tool requires ArcGIS version 10.5 or greater. Exiting...\n")
## sys.exit()
# Main - wrap everything in a try statement
try:
#--------------------------------------------------------------------- Check for ArcInfo License exit if not available
if not arcpy.ProductInfo() == "ArcInfo":
arcpy.AddError("\nThis tool requires an ArcInfo/Advanced license level for ArcGIS Desktop. Exiting...\n")
sys.exit()
# Check out Spatial Analyst License
if arcpy.CheckExtension("Spatial") == "Available":
arcpy.CheckOutExtension("Spatial")
else:
arcpy.AddError("\nSpatial Analyst Extension not enabled. Please enable Spatial Analyst from the Tools/Extensions menu. Exiting...\n")
sys.exit()
arcpy.SetProgressorLabel("Setting Variables")
#------------------------------------------------------------------------ Input Parameters
InputContours = arcpy.GetParameterAsText(0)
dam = arcpy.GetParameterAsText(1)
#outputPoolName = arcpy.GetParameterAsText(2)
print(" \n%s: error: \n%s\n" %
(sys.argv[0], "DBMS type (--DBMS) must be specified."))
parser.print_help()
sys.exit(3)
if (license == ""):
print " \n%s: error: \n%s\n" % (
sys.argv[0], "Authorization file (-l) must be specified.")
parser.print_help()
sys.exit(3)
if (database_type == "SQLSERVER"):
database_type = "SQL_SERVER"
# Get the current product license
product_license = arcpy.ProductInfo()
if (license == ""):
print " \n%s: error: %s\n" % (
sys.argv[0], "Authorization file (-l) must be specified.")
parser.print_help()
sys.exit(3)
# Local variables
instance_temp = instance.replace("\\", "_")
instance_temp = instance_temp.replace("/", "_")
instance_temp = instance_temp.replace(":", "_")
Conn_File_NameT = instance_temp + "_" + database + "_" + username
if os.environ.get("TEMP") == None:
temp = "c:\\temp"
def get_replicas(self):
"""Get geodatabase replicas as ordered dict."""
replicas_props = []
if self.arcpy_found and self.is_gdb_enabled:
# due to bug in arcpy, cannot use da.ListReplicas date properties
# `lastSend` and `lastReceive` for file/personal geodatabases
# because it crashes the Python process
for replica in arcpy.da.ListReplicas(self.path):
od = OrderedDict()
for k, v in GDB_REPLICA_PROPS.items():
if (self.wkspc_type != 'Enterprise geodatabase') and (
k in ('lastReceive', 'lastSend')):
od[v] = 'Not available'
else:
prop_value = getattr(replica, k, '')
if isinstance(
prop_value, datetime.datetime
) and prop_value.year == ESRI_GDB_REPLICA_INF_DATE:
od[v] = ''
else:
if prop_value is not None:
od[v] = prop_value
else:
od[v] = ''
# need at least Standard license of ArcGIS Desktop
# to run this GP tool
if arcpy.ProductInfo() in ('ArcEditor', 'ArcInfo'):
if not hasattr(arcpy, 'ExportReplicaSchema_management'):
# ArcGIS Pro at 1.2 did not have this GP tool
return
replica_schema_xml = os.path.join(tempfile.gettempdir(),
'ReplicaSchema.xml')
arcpy.ExportReplicaSchema_management(
in_geodatabase=self.path,
output_replica_schema_file=replica_schema_xml,
in_replica=replica.name,
)
with open(replica_schema_xml, 'r') as fh:
schema_xml_data = fh.readlines()[0]
try:
os.remove(replica_schema_xml)
except Exception:
pass
xml = ElementTree.fromstring(schema_xml_data)
od['Creation date'] = xml.find('WorkspaceDefinition').find(
'GPReplica').find('CreationDate').text.replace(
'T', ' ')
datasets = xml.find('WorkspaceDefinition').find(
'GPReplica').find('GPReplicaDescription').find(
'GPReplicaDatasets')
datasets_pairs = sorted(((d.find('DatasetName').text,
d.find('TargetName').text)
for d in datasets.getchildren()),
key=lambda pair: pair[0].lower())
od['Datasets'] = '<br>'.join([
'{0} -> {1}'.format(i[0], i[1]) for i in datasets_pairs
])
replicas_props.append(od)
return replicas_props
def CheckArcInfoLicense():
ArcLicense = arcpy.ProductInfo()
if ArcLicense != "ArcInfo":
arcpy.AddError("To run this tool, you must have the Desktop \
Advanced (ArcInfo) license. Your license type is: %s." % ArcLicense)
raise CustomError
installList = arcpy.ListInstallations()
for install in installList:
arcpy.AddMessage("Product: ArcGIS for " + install + " " +
arcpy.GetInstallInfo(install)["Version"] + " SP " +
arcpy.GetInstallInfo()["SPNumber"] + ", Build " +
arcpy.GetInstallInfo()["BuildNumber"])
print("Product: ArcGIS for " + install + " " +
arcpy.GetInstallInfo(install)["Version"] + " SP " +
arcpy.GetInstallInfo()["SPNumber"] + ", Build " +
arcpy.GetInstallInfo()["BuildNumber"])
arcpy.AddMessage("Installed on: " +
arcpy.GetInstallInfo()["InstallDate"] + " " +
arcpy.GetInstallInfo()["InstallTime"])
print("Installed on: " + arcpy.GetInstallInfo()["InstallDate"] + " " +
arcpy.GetInstallInfo()["InstallTime"])
arcpy.AddMessage("Using " + arcpy.ProductInfo() + " license level")
print("Using " + arcpy.ProductInfo() + " license level")
arcpy.AddMessage("Script Version 1.0")
print("Script Version 1.0")
arcpy.AddMessage("--------------------------------")
## This portion of the script will begin by checking the validity of the input files.
## It will then subsequently perform the first step of the script which is to subtract the
##Digital Terrain Model (DTM) from the Digital Surface Model (DSM).
##---------------------------------------------------------------------------------------
arcpy.SetProgressorLabel("Validating input data...")
if arcpy.Exists(inDSM) == True:
print("Input DSM is valid")
arcpy.AddMessage("Input DSM is valid")
def runSystemChecks(folder=None, rerun=False):
import LUCI_PTFs.lib.progress as progress
# Set overwrite output
arcpy.env.overwriteOutput = True
# Check spatial analyst licence is available
if arcpy.CheckExtension("Spatial") == "Available":
arcpy.CheckOutExtension("Spatial")
else:
raise RuntimeError(
"Spatial Analyst license not present or could not be checked out")
### Set workspaces so that temporary files are written to the LUCI scratch geodatabase ###
if arcpy.ProductInfo() == "ArcServer":
log.info('arcpy.env.scratchWorkspace on server: ' +
str(arcpy.env.scratchWorkspace))
# Set current workspace
arcpy.env.workspace = arcpy.env.scratchGDB
else:
# If rerunning a tool, check if scratch workspace has been set. If it has, use it as it is (with temporary rasters and feature classes from the previous run).
scratchGDB = None
if rerun:
xmlFile = progress.getProgressFilenames(folder).xmlFile
if os.path.exists(xmlFile):
scratchGDB = readXML(xmlFile, 'ScratchGDB')
if not arcpy.Exists(scratchGDB):
log.error('Previous scratch GDB ' + str(scratchGDB) +
' does not exist. Tool cannot be rerun.')
log.error('Exiting tool')
sys.exit()
if scratchGDB is None:
# Set scratch path from values in user settings file if values present
scratchPath = None
try:
if os.path.exists(configuration.userSettingsFile):
tree = ET.parse(configuration.userSettingsFile)
root = tree.getroot()
scratchPath = root.find("scratchPath").text
except Exception:
pass # If any errors occur, ignore them. Just use the default scratch path.
# Set scratch path if needed
if scratchPath is None:
scratchPath = configuration.scratchPath
# Create scratch path folder
if not os.path.exists(scratchPath):
os.makedirs(scratchPath)
# Remove old date/time stamped scratch folders if they exist and if they do not contain lock ArcGIS lock files.
for root, dirs, files in os.walk(scratchPath):
for dir in dirs:
# Try to rename folder. If this is possible then no locks are held on it and it can then be removed.
try:
fullDirPath = os.path.join(scratchPath, dir)
renamedDir = os.path.join(scratchPath,
'ready_for_deletion')
os.rename(fullDirPath, renamedDir)
except Exception:
# import traceback
# log.warning(traceback.format_exc())
pass
else:
try:
shutil.rmtree(renamedDir)
except Exception:
# import traceback
# log.warning(traceback.format_exc())
pass
# Create new date/time stamped scratch folder for the scratch GDB to live in
dateTimeStamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
scratchGDBFolder = os.path.join(scratchPath,
'scratch_' + dateTimeStamp)
if not os.path.exists(scratchGDBFolder):
os.mkdir(scratchGDBFolder)
# Create scratch GDB
scratchGDB = os.path.join(scratchGDBFolder, 'scratch.gdb')
if not os.path.exists(scratchGDB):
arcpy.CreateFileGDB_management(os.path.dirname(scratchGDB),
os.path.basename(scratchGDB))
# Try to remove old scratch path if still exists
try:
shutil.rmtree(configuration.oldScratchPath, ignore_errors=True)
except Exception:
pass
# Set scratch and current workspaces
arcpy.env.scratchWorkspace = scratchGDB
arcpy.env.workspace = scratchGDB
# Scratch folder
scratchFolder = arcpy.env.scratchFolder
if not os.path.exists(scratchFolder):
os.mkdir(scratchFolder)
# Remove all in_memory data sets
arcpy.Delete_management("in_memory")
# Check disk space for disk with scratch workspace
freeSpaceGb = 3
if getFreeDiskSpaceGb(arcpy.env.scratchWorkspace) < freeSpaceGb:
log.warning("Disk containing scratch workspace has less than " +
str(freeSpaceGb) +
"Gb free space. This may cause this tool to fail.")
import arcpy print arcpy.ProductInfo()
