Here are some sample python toolboxes that might give you some ideas for your project. The first is basically a python toolbox version of the script tool described in the blog post mentioned in my previous post. I have added a dropdown for the weight values. Select a feature layer or feature class; select a field in that feature; choose an attribute and select the weight.
import arcpy
class Toolbox(object):
def __init__(self):
"""Define the toolbox (the name of the toolbox is the name of the
.pyt file)."""
self.label = "Select Value"
self.alias = "selection"
self.tools = [SelectValue]
class SelectValue(object):
def __init__(self):
"""Define the tool (tool name is the name of the class)."""
self.label = "Select Value"
self.description = ""
self.canRunInBackground = False
self.fcfield = (None, None)
def getParameterInfo(self):
"""Define parameter definitions"""
inFeature = arcpy.Parameter(
displayName="Input Features",
name="inFeature",
datatype=["DEFeatureClass","GPFeatureLayer"],
parameterType="Required",
direction="Input")
fieldName = arcpy.Parameter(
displayName="Field Name",
name="fieldName",
datatype="Field",
parameterType="Required",
direction="Input")
fieldName.parameterDependencies = [inFeature.name]
fieldName.filter.list = ["Short", "Long", "Double", "Float", "Text"]
fldProperty = arcpy.Parameter(
displayName="Property",
name="fldProperty",
datatype="String",
parameterType="Required",
direction="Input")
fldProperty.parameterDependencies = [inFeature.name, fieldName.name]
weightVal = arcpy.Parameter(
displayName="Weight",
name="weightVal",
datatype="String",
parameterType="Required",
direction="Input")
weightVal.filter.list = [ 1, 2, 5, 8, 10 ]
weightVal.value = weightVal.filter.list[0]
params = [inFeature, fieldName, fldProperty, weightVal]
return params
def isLicensed(self):
"""Set whether tool is licensed to execute."""
return True
def updateParameters(self, parameters):
"""Modify the values and properties of parameters before internal
validation is performed. This method is called whenever a parameter
has been changed."""
if parameters[0].value and parameters[1].value:
fc, col = parameters[0].valueAsText, parameters[1].valueAsText
desc = arcpy.Describe(parameters[0])
if desc.dataType == 'FeatureLayer':
fc = desc.catalogPath
if self.fcfield != (fc, col):
self.fcfield = (fc, col)
parameters[2].filter.list = [str(val) for val in sorted(set(row[0] for row in arcpy.da.SearchCursor(fc,col)))]
if parameters[2].value not in parameters[2].filter.list:
parameters[2].value = parameters[2].filter.list[0]
return
def updateMessages(self, parameters):
"""Modify the messages created by internal validation for each tool
parameter. This method is called after internal validation."""
return
def execute(self, parameters, messages):
"""The source code of the tool."""
inFeature = parameters[0].valueAsText
fieldName = parameters[1].valueAsText
fldProperty = parameters[2].valueAsText
weightVal = parameters[3].valueAsText
messages.addMessage(
"\nInput Feature: {}".format(inFeature))
messages.addMessage(
"\nSelected Field: {}".format(fieldName))
messages.addMessage(
"\nWeight Value: {}".format(weightVal))
messages.addMessage(
"\nField Property: {}".format(fldProperty))
desc = arcpy.Describe(parameters[0])
messages.addMessage(
"\nDataType: {}\nPath: {}".format(desc.dataType, desc.catalogPath))
return
The second reads domain information into a list for the dropdown. In this example, the domain is hard-coded to a specific domain in a specific database (lines 32-33). It could be modified to allow the user to select the database and domain name.
import arcpy, operator
def getDomain(gdb, domainName):
domDict = {}
domains = arcpy.da.ListDomains(gdb)
for domain in domains:
if domain.name == domainName:
coded_values = domain.codedValues
for val, desc in coded_values.items():
domDict[desc] = val
return domDict
class Toolbox(object):
def __init__(self):
"""Define the toolbox (the name of the toolbox is the name of the
.pyt file)."""
self.label = "Toolbox"
self.alias = ""
self.tools = [Tool]
class Tool(object):
def __init__(self):
"""Define the tool (tool name is the name of the class)."""
self.label = "Tool"
self.description = ""
self.canRunInBackground = False
self.domain = getDomain(r'C:\Path\to\file.gdb',
'DomainName')
def getParameterInfo(self):
"""Define parameter definitions"""
domValue = arcpy.Parameter(
displayName = "Select Domain",
name = "domValue",
datatype = "GPString",
parameterType = "Required",
direction = "Input")
domValue.filter.type = "ValueList"
domValue.filter.list = [x[0] for x in sorted(self.domain.items(), key=operator.itemgetter(1))]
domValue.value = domValue.filter.list[0]
return [domValue]
def isLicensed(self):
"""Set whether tool is licensed to execute."""
return True
def updateParameters(self, parameters):
"""Modify the values and properties of parameters before internal
validation is performed. This method is called whenever a parameter
has been changed."""
return
def updateMessages(self, parameters):
"""Modify the messages created by internal validation for each tool
parameter. This method is called after internal validation."""
return
def execute(self, parameters, messages):
"""The source code of the tool."""
messages.addMessage('Selected: {} -- Code: {}'.format(parameters[0].value, self.domain[parameters[0].value]))
return
Hope this gives you some ideas.
