Added Class 13

Author: marecotec

Classes/13_Toolboxes/Step_1.py

@@ -0,0 +1,46 @@
+
+#####
+# Step 1 - "Traditional" ArcToolboxes
+#####
+
+# In this process, we will create a "Script Tool" which will create a toolbox that we can interact with using the
+# script below. This is a Walk Through Session, so follow as I go along.
+
+# First you should add the Toolbox that I provided in Step_1_Data.zip, and we will look at the script and
+# code used to initialize it.
+
+## Add Toolbox provided to ArcToolbox
+
+# Now let's create our own. The script is provided below, and a brief description of the workflow is provided.
+
+# 1. Open ArcToolbox, rc Add Toolbox, click new Toolbox icon in window that pops up, call it "Testing Toolbox.tbx"
+# 2. Inside this new Toolbox, rc Add "Script", then add the following params:
+##### Name = TestTool1 - This is the machine name of the script
+##### Label = Test Tool 1 - This shows up in ArcToolbox as the name of the tool.
+##### Description = "Testing a tool, does nothing really".
+##### Leave the rest as it is.
+# 3. Click Next, now browse to select the "Script File", you will note that I have provided one for you in
+# Step_1_Data.zip, called Testing_Tool_Script.py.
+# 4. Click Next, here you add the individual parameters, we are going to add a display name of "Shapefile" in the
+# top most box, on the left, and a datatype of "Shapefile", leave the parameter settings as their defaults.
+# 5. Click finish! Test it on the Shapefile in the "Test Shapefile" folder.
+
+
+
+# Task - Taking the more complex code below, I want you to turn this into a toolbox. Note that it accepts
+# three arguments, one input line file and one input polygon file, and an output file. You do not need to
+# change the code below, just put it in it's own Python file, and then create the appropriate parameters
+# inside the toolbox settings as we just walked through.
+
+
+# import arcpy
+# import sys
+#
+# input_line = sys.argv[1]
+# input_polygon = sys.argv[2]
+# output = sys.argv[3]
+#
+# arcpy.Clip_analysis(in_features=input_line,
+#                     clip_features=input_polygon,
+#                     out_feature_class=output,
+#                     cluster_tolerance="")

Classes/13_Toolboxes/Step_1_Answers.zip

@@ -0,0 +1,64 @@
+
+#####
+# Step 2 - Python Toolboxes
+#####
+
+# The process to create a "Traditional" toolbox takes you out of Python, and somewhat can limit what you can
+# do. The solution is an all Python Toolbox, a hidden gem of python and arcpy. There is a lot of information
+# about them here; http://desktop.arcgis.com/en/arcmap/10.3/analyze/creating-tools/a-quick-tour-of-python-toolboxes.htm
+
+# The template for a Python toolbox uses classes and functions. See a class as a higher level function that allows
+# us to keep code separate. Below is an example template, I shall walk you through the different parts:
+
+# Note:
+### class Toolbox defines the toolbox, you only have this once, but you can have multiple tool classes, i.e.
+### Tool, Tool1, Tool2 etc, just extend the self.tools = [Tool, Tool1, Tool2] and add the corresponding
+### classes for the new tools.
+
+
+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 = "Toolbox"
+        self.alias = ""
+
+        # List of tool classes associated with this toolbox
+        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
+
+    def getParameterInfo(self):
+        """Define parameter definitions"""
+        params = None
+        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."""
+        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."""
+        return
+
+# I have created a rudimentary Python Toolbox for you in Step_2_Data/Python_Toolbox_Example, add this to ArcToolbox

Classes/13_Toolboxes/Step_1_Data.zip

@@ -0,0 +1,46 @@
+
+#####
+# Step 3 - Make your own Python Toolbox!
+#####
+
+# Task - Using the code I provide below (basically , including the parameters that I have prepared for you (note, you can
+# find all the Python Toolbox Parameters here:
+# http://desktop.arcgis.com/en/arcmap/10.3/analyze/creating-tools/defining-parameters-in-a-python-toolbox.htm)
+
+# I want you to attempt to construct a working Python Toolbox. Hint the code is the same as we used before for the
+# traditional toolbox, however, I have changed how the arguements are provided to the tool.
+
+# Code for parameters function
+params = []
+input_line = arcpy.Parameter(name="input_line",
+                             displayName="Input Line",
+                             datatype="DEFeatureClass",
+                             parameterType="Required",  # Required|Optional|Derived
+                             direction="Input",  # Input|Output
+                             )
+params.append(input_line)
+input_polygon = arcpy.Parameter(name="input_polygon",
+                                displayName="Input Polygon",
+                                datatype="DEFeatureClass",
+                                parameterType="Required",  # Required|Optional|Derived
+                                direction="Input",  # Input|Output
+                                )
+params.append(input_polygon)
+output = arcpy.Parameter(name="output",
+                         displayName="Output",
+                         datatype="DEFeatureClass",
+                         parameterType="Required",  # Required|Optional|Derived
+                         direction="Output",  # Input|Output
+                         )
+params.append(output)
+return params
+
+# Code for execution function
+input_line = parameters[0].valueAsText
+input_polygon = parameters[1].valueAsText
+output = parameters[2].valueAsText
+
+arcpy.Clip_analysis(in_features=input_line,
+                    clip_features=input_polygon,
+                    out_feature_class=output,
+                    cluster_tolerance="")

Classes/13_Toolboxes/Step_2.py

@@ -0,0 +1,73 @@
+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 = "Python Toolbox Clippy"
+        self.alias = ""
+
+        # List of tool classes associated with this toolbox
+        self.tools = [Clippy]
+
+
+class Clippy(object):
+    def __init__(self):
+        """Define the tool (tool name is the name of the class)."""
+        self.label = "Clippy Tool"
+        self.description = ""
+        self.canRunInBackground = False
+
+    def getParameterInfo(self):
+        """Define parameter definitions"""
+        params = []
+        input_line = arcpy.Parameter(name="input_line",
+                                     displayName="Input Line",
+                                     datatype="DEFeatureClass",
+                                     parameterType="Required",  # Required|Optional|Derived
+                                     direction="Input",  # Input|Output
+                                     )
+        params.append(input_line)
+        input_polygon = arcpy.Parameter(name="input_polygon",
+                                        displayName="Input Polygon",
+                                        datatype="DEFeatureClass",
+                                        parameterType="Required",  # Required|Optional|Derived
+                                        direction="Input",  # Input|Output
+                                        )
+        params.append(input_polygon)
+        output = arcpy.Parameter(name="output",
+                                 displayName="Output",
+                                 datatype="DEFeatureClass",
+                                 parameterType="Required",  # Required|Optional|Derived
+                                 direction="Output",  # Input|Output
+                                 )
+        params.append(output)
+        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."""
+        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."""
+        input_line = parameters[0].valueAsText
+        input_polygon = parameters[1].valueAsText
+        output = parameters[2].valueAsText
+
+        arcpy.Clip_analysis(in_features=input_line,
+                            clip_features=input_polygon,
+                            out_feature_class=output,
+                            cluster_tolerance="")
+        return

Classes/13_Toolboxes/Step_2_Data.zip

@@ -1,6 +1,7 @@
 import arcpy
 
-
+
+
 arcpy.AddMessage("Hello, this is an add message output")
-
+
 print("This is a print statement")