Alteryx Designer Knowledge Base

Definitive answers from Designer experts.
Register for the upcoming Live Community Q&A Session - and don't forget to submit your questions for @DeanS regarding the future role of analytics here.

Getting Started with SnakePlane and SnakePlane Pilot: A Tutorial


This is a tutorial (with pictures!) for getting SnakePlane Pilot set up on your machine and working through the processes of building a Python SDK tool, debugging the tool, and packaging the tool with SnakePlane and SnakePlane Pilot.


There are three parts to this tutorial:


Part 1: Setting Up SnakePlane Pilot


Part 2: Building a Tool with SnakePlane (and SnakePlane Pilot)


Part 3: Debugging and Packaging a Tool with SnakePlane Pilot


For additional help getting started with SnakePlane and SnakePlane Pilot, please see the corresponding README documents available in the SnakePlane repository on GitHub.


Part 1: Setting Up SnakePlane Pilot


The very first step for getting started with SnakePlane is setting up SnakePlane Pilot on your workstation. SnakePlane Pilot is a framework for developing tools with SnakePlane that makes the process more streamlined.


Note: This tutorial sets up SnakePlane Pilot in PyCharm, but the same or a similar process should work in the (Python-supported) IDE of your choice.


Without further ado, let's get into it.


  1. Navigate to the SnakePlane repository on GitHub.

    1. Note that the SnakePlane repo includes a copy of SnakePlane Pilot, so this is the only thing you will need to install to get up and running.

  2. Clone or download the repository on to your workstation. 


    1. If you downloaded the repository as a zip file, extract it and save the extracted folder snakeplane to the directory on your computer you’d like to work from. 

    2. If you cloned the repository to your desktop, all you will need to do is note the location you saved the repository on your local machine.

      Regardless of how you got SnakePlane on to your computer, the next step is to set up your python virtual environment for SnakePlane. The virtual environment will be created using Alteryx’s installation of Python (ensuring your tools are made with an Alteryx-compatible version of Python) and will include all package dependencies required for SnakePlane and the Python SDK.

      If you have never used the Python SDK before, make sure you following the Python installation instructions in the Python SDK help documentation.

      Note: SnakePlane Pilot will only work properly with an admin version of Alteryx Designer.



  3. To set up the virtual environment for SnakePlane, we need to run the script setup_environ.bat found under pilot\env.

    Note: This script is configured to look for the Python virtual environment under C:\Program Files\Alteryx\bin\Miniconda3\python.exe (the default install location for Admin Alteryx Designer). If you have installed an admin version of Alteryx Designer in a different directory, you will need to edit this script as well as If you do need to make changes, note that uses "\\" instead of "\" for filepath specification.

    1. Open a command prompt or a PowerShell terminal on your machine.

    2. In the terminal, change your working directory to the pilot folder within your copy of SnakePlane. For example:

      cd YOURDIRECTORYHERE\snakeplane\pilot
    3. After changing your working directory, run the setup_environ.bat script from this directory:
    4. Once the script is finished running, you should see new folders associated with your virtual environment populated in the pilot\env directory:


    5.  With the virtual environment set up for SnakePlane, you can create a SnakePlane Pilot project in your IDE.

      a. Open your IDE (Pycharm) and select Create New Project.


      b. Select the SnakePlane Pilot directory as the Base Directory for your new project.


      c. From the Dropdown Project Interpreter option in the Create Project window, configure your project interpreter to an Existing Interpreter.

      1. Specify the existing interpreter as the virtual environment created by SnakePlane Pilot, found under ...\pilot\env\Scripts\python.exe. You may need to select the option on the right side of the bar to browse to the virtual environment.


      2.  After selecting the Python interpreter, click the Create button in the bottom right corner of the Create Project Window.


      3.  After clicking create, you will see a message that says: “The directory “YourBaseFilePath\snakeplane\pilot’ is not empty. Would you like to create a project from existing sources instead?” Select Yes.


    6.  You have now created your SnakePlane Pilot environment, but there are a few more steps to getting it fully set up.

      a. Navigate to File > Settings > Tools > Terminal, and configure your Shell path to your command prompt by typing in cmd.exe.


      b. Once your project has been configured to use Command Prompt as a terminal, you can run the script activate.batfound under env\scripts\activate.bat in the PyCharm terminal to enable the built-in commands.


      c. After running the script, try running inv -l in the terminal to confirm the commands are accessible. This command should return a list of available tasks.

      Note: inv and invoke are interchangeable to call invoke commands.



You should now be set up to create your first SnakePlane tool! The next section is a step-by-step tutorial for creating a tool with SnakePlane in SnakePlane Pilot.

Part 2: Building a Tool with SnakePlane (and SnakePlane Pilot)

In this tutorial, I am going to walk through creating a Python SDK tool with SnakePlane and SnakePlane Pilot.  To follow along with this tutorial, you will need to have set up SnakePlane Pilot on your machine. Lucky for you, Part 1 of this tutorial shows you how to do just that.


In this section, we are going to build a Radar Plot tool (for the super practical and important application of plotting Pokemon stats).




  1. To start, we are going to create a copy of a SnakePlane example tool in the src folder in the Pilot directory ( snakeplane > pilot > src). This is the best way to ensure you have all the required components for making a tool, especially when you are just starting out. For this tutorial, let's copy ExampleStreamTool.


  2. Save the copy to the same directory. You will likely be prompted to rename the file. Give it the name of your new tool (we will call our tutorial tool radarPlot).


  3. Now you can start renaming and editing each of the components within the folder to match the name of your new tool.

    1. Navigate to the config folder in your new tool’s directory (src > radarPlot > config). Delete the icon file (ExampleStreamToolIcon.png) and search the internet for the perfect image. Save the image to the config directory with the name of your tool plus Icon.png (radarPlotIcon.png).

    2. In the same folder, change the name of the config file (ExampleStreamToolConfig.xml) to reflect your tool’s name (radarPlotConfig.xml) and open it up for editing. In the config file, you will need to change the GuiSettings section to match the filenames of your tool’s components, as well as the MetaInfo section. We won’t touch the Input or Output Connections for this tool, but if you’re going off script this might be something you need to change.

      The contents of our radarPlotConfig.xml file now looks like this:

      <?xml version="1.0"?>
        <EngineSettings EngineDll="Python" EngineDllEntryPoint="" SDKVersion="10.1" />
        <GuiSettings Html="gui/radarPlotGui.html" Icon="radarPlotIcon.png" SDKVersion="10.1">
            <Connection Name="Input" AllowMultiple="False" Optional="False" Type="Connection" Label=""/>
            <Connection Name="Output" AllowMultiple="False" Optional="False" Type="Connection" Label=""/>
            <Name>Radar Plot</Name>
            <Description>Radar Plot Tool</Description>
            <SearchTags>python, sdk, visualization, radar, plot, radar plot</SearchTags>
            <Company>Alteryx, Inc.</Company>
    3.  With the XML file configured, navigate to the gui folder (src > radarPlot > gui) and rename the .html file (ExampleStreamToolGui.html) to reflect your tool’s name (radarPlotGui.html). Now we can edit the tool’s interface. If you want to do more than copy and paste what I’ve written (see below) I’d suggest looking at the help documentation and this blog post to get you going.

      Our tool's configuration includes a drop-down widget to select a column of Plot title's (the Pokemon's name) and a listbox widget that allows the user to select which fields they'd like to plot (the list box is configured to only accept numeric fields).

      The contents of our Gui file looks like this:

      <!DOCTYPE html>
          <meta charset="UTF-8">
          <title>XMSG("Project Q")</title>
          <script type="text/javascript">
              // Include the base GUI library.
              document.write('<link rel="import" href="' + window.Alteryx.LibDir + '2/lib/includes.html">');
          <style type="text/css">
              body {
                  margin: 15px;
              #config {
                  padding-bottom: 20px;
              .header-ruler {
                  background-color: #cccccc;
                  height: 1px;
                  border: 0 none;
                  flex-grow: 1;
                  margin-top: 0.625em;
                  margin-left: 10px;
              .header-message {
                  color: #52617f;
                  font-size: 1.78em;
                  font-weight: normal;
                  padding-bottom: 0px;
                  margin: 0px;
                  margin-bottom: 20px;
                  display: flex;
                  justify-content: flex-start;
                  align-items: center;
              h2 {
                  padding: 10px 0 5px 0;
                  margin: 15px 5px 5px 0;
                  font-size: 1.556em;
                  font-weight: normal;
                  color: #52617f;
              h3 {
                  color: #8698ba;
                  font-size: 1.167em;
                  margin: 6px 0px 3px 0;
                  padding: 0;
                  font-weight: normal;
                  line-height: 1.42857143;
              h3.container:first-child {
                  border-top: 0;
              .flex-row {
                  margin: 0;
                  padding: 0;
              .flex-row li {
                  list-style: none;
          <div class="header-message">
              <div>XMSG("Radar Plot")</div>
              <hr class="header-ruler">
          <br id="config">
                  <div>XMSG("Title Field")</div>
                  <ayx data-ui-props ="{
                  type: 'DropDown'}"
                       data-item-props ="{
                       dataName: 'names',
                       dataType: 'FieldSelector',
                       anchorIndex: '0',
                       connectionIndex: '0'}" > </ayx>
                  <div>XMSG("Fields to Plot")</div>
                  <ayx data-ui-props="{
                  type: 'ListBox',
                  placeholder: 'Select Fields',
                  searchable: true}"
                  dataName: 'fields',
                  dataType: 'FieldSelectorMulti',
                  fieldType: 'Numeric',
          <script type="text/javascript">
              Alteryx.Gui.BeforeLoad = (manager, AlteryxDataItems, json) => {
              Alteryx.Gui.AfterLoad = (manager) => {

  4. Now that the interface and configuration files are set up, we can start creating the tool's logic in the Python script (src > radarPlot > engine > src)!

    1. First, add code to import the additional required libraries for our tool. Our tool will require matplotlib, as well as the pi function from the math package, and re (for regex functionality).

      # 3rd Party Libraries
      import AlteryxPythonSDK as sdk
      from snakeplane.plugin_factory import PluginFactory
      # Our added libraries
      import matplotlib.pyplot as plt
      from math import pi
      import re
    2. To make sure these packages end up in our final tool, we should add them to the SnakePlane Pilot virtual environment. If you are using Pycharm, the easiest way to do this is to navigate to File > Settings > Project and click the little plus button on the right-hand side to add a package. We will only need to add matplotlib. 


      When you build your tool, these packages will be included in the tool’s virtual environment, so it is important to keep tabs on what you add, and what really needs to be packaged with your tool.

    3.  Back in the Python code ( we need to modify the plugin factory constructor to reference the name of our new tool. In the line of code that reads PluginFactory("ExampleStreamTool"), replace ExampleStreamTool with radarPlot

      # Initialization of the plug in factory, used for making the AyxPlugin class
      factory = PluginFactory("radarPlot")

      Note: it is important that the name you provide the plugin factory constructor matches the directory name of the tool exactly. This is because the plugin factory uses this provided name to locate the configuration (XML) file for the plugin. If this argument is not set correctly, you will not be able to use your tool in Alteryx.

    4. Next, we encounter our first decorator, initialize plugin! This is where we will specify the specific plugin initialization behavior.

      1.  Delete all of the code in the example tool between the comment  """Initialize the example tool""" and return True.


      2.  In this section, we are going to add code that returns the configuration options set by the user in Alteryx to the Python script. In our GUI, there are two configuration options; the fields to be plotted on the radar chart (the listbox widget) and the field that contains the titles of the plots (a drop down). 

        Using the input_mgr.workflow_config() SnakePlane function, we can call the tool's configuration in a workflow by referencing the dataName we gave to the interface widgets in the Gui file (our listbox is named "fields" and our title drop-down widget is named "names").


        We will save these configuration inputs as user_data.fields and user_data.names, respectively. Saving the input configurations in user_data allows the information to be accessed later in the script.

            # Get the selected value from the GUI and save it for later use in the user_data
            user_data.fields = (input_mgr.workflow_config["fields"])
            user_data.names = (input_mgr.workflow_config["names"])
      3. Next, we can add code to return error messages at initialization if the user does not configure the tool. We want to start by setting the variable initSuccess to True by default, and then write two if statements that check if the user_data variables are equal to None. If they are, we use the logger functionality to display an error message, and set the initSucess to False.

            initSuccess = True
            if user_data.fields is None:
                logger.display_error_msg("Select Fields to Plot")
                initSuccess = False
            if user_data.names is None:
                logger.display_error_msg("Select the Field that Contains the Plot Labels")
                initSuccess = False
      4.  At the end of the factory.initialize_plugin, we want to return the variable initSuccess. If the interface has been configured correctly, initiSuccess will be equal to True, and we will be able to run the tool and move on to the next section of code. If initSuccess is False, the user will see an error message in Alteryx instructing them to fix their configuration.

           return initSuccess
    5. The next decorator,@factory.process_data is (intuitively) for processing data. This section is where the bulk of your custom tool code will go.

      1. The first thing to note about the factory.process_data() decorator are the two arguments mode and input_type.

        1. Mode allows us to specify which mode we want the plugin to operate in. There are two possible modes; batch and stream. Batch mode brings in all of the input records all at once, which is handy if you are building a tool that needs to see all records simultaneously (like a predictive tool). Stream mode brings in the input records a single row at a time. 

        2. Input_type specifies the format of the input data. The two options are list (this is the default) and dataframe. List brings in data as a single list in stream mode or a list of lists in batch mode. Dataframe brings in the input as a pandas dataframe.

      2. For this tool, we will set the mode to stream and the input_type to dataframe.

        @factory.process_data(mode="stream", input_type="dataframe")
      3. We will leave the next few lines of code in the example tool as is. input_mgr brings in the input anchor connection and the brings in the actual data from the anchor.
        def process_data(input_mgr, output_mgr, user_data, logger):
            """Run alpha-beta filtering and stream the results."""
            # Get the input anchor
            input_anchor = input_mgr["Input"][0]
            # Get the input data. Since we're streaming, this is only a single row
            data =
      4. Now we can start adding custom code to this section. After the data is brought in (data =, we can subset the input data to the fields the user selected to plot. We can do this using the user_data.fields variable we created in the initialize plugin section.

            # Subset input data to select plotting fields
            subset = data[user_data.fields.split(",")]
      5. Similarly, we can pull out the title column, specified by the user in the tool’s configuration.

            # extract plot title
            name = data.iloc[0][user_data.names]
      6. Now, we can add the code for our radar plot functionality. The code to create a radar plot is incorporated and adapted from an example on the Python Graph Gallery.

            # Code Source: Access Date: 4.3.19

        # Calculate the number of variables to be plotted categories = list(subset) N = len(categories) # Create list of values to be plotted on radar chart
        # repeat first value to close circle values = subset.loc[0].tolist() values += values[:1] values = [float(i) for i in values] # find the angles for each axis in radar plot angles = [n/float(N)*2*pi for n in range(N)] angles += angles[:1] # create a blank radar plot ax = plt.subplot(111, polar=True) # draw each axis per variable and add the axis labels plt.xticks(angles[:-1], categories, color="grey", size=8) # add the y labels to the chart ax.set_rlabel_position(0) plt.yticks([50, 100, 150], ["50", "100", "150"], color="grey", size=7) plt.ylim(0, 200) # plot the angles and values of original data on chart ax.plot(angles, values, linewidth=1, linestyle='solid') # fill in the area of the plotted points ax.fill(angles, values, 'b', alpha=0.1) # add title to plot ax.set_title(name)
      7. With the plot created, we need to write it back out so that it can be populated in Alteryx. The way we are going to do this is by creating a temporary file of the plot, and referencing the file path in the tool’s output.

        1. First, we get the temporary file path using the output_mgr function get_temp_file_path. Then, we use some regex to replace the .tmp extension generated by the function with .png and replace the slashes.

              # create and prepare temp file
              filepath = output_mgr.get_temp_file_path()
              filepath = re.sub('tmp', 'png', filepath)
              filepath = filepath.replace('\\', '/')
        2. Then, we save the figure to the temporary file path we generated and clear the plot so that a new plot will be created when the next row of input data is streamed in.

              # save figure as temporary file
              # clear plot
      8. With the temporary file written out, and the plot cleared, we can work on making the plot populate in Alteryx. We are going to modify the existing code from the original example tool under the comment that says Append our value to the data. 


      9. To include the original fields in the output of the tool, we are just going to append our newly created field to the input data frame. We are going to name the new field “Figure”, and the contents of the new field will be the file path of the image’s temporary file, embedded as a hyperlink.

            # Append our value to the data
            data['Figure'] = ['<img src="' + filepath + '" />"']
      10. We can leave the last two lines of code in this section alone. The function output_mgr is grabbing the output anchor, and the final line of code, is assigning out output data frame’s data to the anchor.

            # Assign to the output
            output_anchor = output_mgr["Output"]
   = data
    6. Our final decorator, @factory.build_metadata, is where we can specify the output metadata for our tool. We aren’t going to change much with this section, just modify the code under the comment # Add the new column. We are going to modify the code to reflect the name of our new column, as well as specify the field type, size, and source. Specifying the source as "Report:Image:" is what makes the image show up correctly in Alteryx. 

      def build_metadata(input_mgr, output_mgr, user_data, logger):
          """Build metadata for this example tool."""
          # Set up the metadata, we're adding a column of floats
          input_anchor = input_mgr["Input"][0]
          metadata = input_anchor.metadata
          # Add the new column
          metadata.add_column("Figure", sdk.FieldType.v_string, size=1000000, source="Report:Image:")
          # Assign the metadata to the output
          output_anchor = output_mgr["Output"]
          output_anchor.metadata = metadata
    7. The final line of the Python script needs to export the plugin. 

      AyxPlugin = factory.generate_plugin()


We have built out our Python tool with SnakePlane! In the next section, I will review the functionality of SnakePlane pilot that helps with debugging and packaging a Python SDK tool. If you'd like a copy of the tool I demonstrated in this tutorial, you can download it here

Part 3: Debugging and Packaging a Tool with SnakePlane Pilot


The finishing steps of building out a Python SDK tool are debugging and then packaging it to be shared with other people. SnakePlane Pilot has functionality that makes this process pretty seamless.


If you need to debug, or just want to start using your tool in your own Designer instance, the first step will be building the tool. The process to do so only requires a few invoke commands. 


Building your Tool:



  1. Make sure you have activated the built-in SnakePlane Pilot commands.
    1. To activate the commands, run the script env\scripts\activate.ps1 in the PowerShell terminal.

  2. If you have installed any package dependencies to the virtual environment (as we did in our example radarPlot tool) you will need to freeze them. To do so, run the following command in your PowerShell terminal:

    inv freeze
  3. Now, we can run the build command. The first time you build your tool, run the following command:

    inv build <name> -u
  4. The tool should now exist in Designer (you might need to restart Designer if you’ve had it open during this process).




Debugging a Python SDK tool can feel challenging because of the disconnect between the Python script and the Alteryx Engine. You can build out an algorithm in Python, and paste it into a Python SDK script with only a vague idea of how the data will pass in and out of the code from Alteryx, making the integration process feel kind of like a guess. Luckily, you can use the Python debug package to see the data pass through your script step by step while embedded in Alteryx. This is the same process described in this post. 


Debugging your Tool:


  1. Create a workflow that includes your tool, configured with the settings you’d like to test the tool with.


  2. Save this workflow in the debug_workflows folder (snakeplane > pilot > debug_workflows) with the same name as your tool (YourToolsName.yxmd). If your directory does not include a debug_workflows folder, add one!

  3. Import the python debugger library (import pdb) to your tool's script, and add the line pdb.set_trace() to wherever you would like to interact with your code in the console. These breaks will allow you to interact with your Python code in the console, and determine where or why your code might be breaking.


  4. Make sure you have activated the built-in SnakePlane Pilot commands.

    1. To activate the commands, run the script env\scripts\activate.ps1 in the PowerShell terminal.

  5. Rebuild your tool with the command:

    invoke build <YourToolsName>

    Note: you do not need to include -u after building the tool the first time unless you add dependencies to the virtual environment or change the XML file.

  6. Run the following command in your PowerShell terminal (associated your SnakePlane Pilot directory) to run your workflow in the console (note that this requires a Designer with automation/scheduler license):

    invoke debug <YourToolsName>
  7. Every time you make changes to your tool’s code, you will need to rebuild your tool for the changes to take effect. Remember that debugging is an iterative process, and can start at any point you'd like to see what is actually happening with your tool (I tend to start using the debugger very early in development).


Once your tool is working exactly how you always imagined it would you can use SnakePlane Pilot to package your tool into a .yxi, and share it with the rest of the world.

Packaging your Tool:

  1. Make sure you have activated the built-in SnakePlane Pilot commands.

    1. To activate the commands, run the script env\scripts\activate.ps1 in the PowerShell terminal.

  2. Make sure there is a folder named target_yxis in snakeplane > pilot. If there is not, add one! This is where your packaged tool(s) will end up.

  3. In the package folder in the snakeplane > pilot directory, edit the files config.xml and icon.png to reflect the tool(s) (you can include more than one tool in a single .yxi package) you would like package. 
  4. Once you have your package folder ready, to package your tool to a .yxi file, run the following command in your PowerShell terminal:

    invoke package <YourToolsName>
  5. Your packaged tool(s) should now live, as a .yxi file ready for the world, in the target_yxis folder (snakeplane > pilot > target_yxis). 

  6. Send your new packaged tool to all of your friends!


So ends our multi-part SnakePlane tutorial. I hope you are now ready to build out your own tools with this abstraction layer! If you run into any issues with SnakePlane, please do not hesitate to submit them on the GitHub repository. You can also find additional supporting documentation on the GitHub repo here for SnakePlane, and here for SnakePlane pilot.

11 - Bolide

Suggestion - Part 1 step 3.3 requires access to pip domains (e.g. If you work for a company that uses a proxy, make sure your proxy has these domains available before starting the "env\setup_environ.bat" script.

11 - Bolide

Another tip - In Part 3, "Debugging your Tool" step 1, make sure you set the fields you want to plot to numeric data types (Int works nicely). I thought my copy/paste skills were failing until I tried ploting the name field and saw it was faliing to proces the string data type. All I had to do was change the data types for the numeric fields in the Select tool, and voila!

11 - Bolide

@SydneyF - I finished up the tutorial yesterday, and it worked nicely! Thank you for the demo! 🙂


Couple questions if that's okay ...


  1. Does the abstraction measurably change performance of the resulting tools? My knowledge of python decorators is very basic at the moment. I'm hoping the answer is no considering, but wasn't sure if you and others had tested this already.
  2. You mention that we can package multiple tools in one YXI file, which I was already aware of and planning to make use of the grouping of tools with the same virtual environment feature released in 2019.1. Do we just 'invoke build <tool_#1>' all of the tools into the 'package' directory and then 'invoke package <tool_collection>' at the end? My reading of the shows me that would work if all the tools are built into that directory, but just wanted to confirm that was the correct process for multiple tools.
  3. Will Alteryx be bringing SnakePlane to Inspire? Or do I have to bring my own snakes? 🙂 But seriously, is there a forum for hacking SDK somewhere during Inspire? I do see @BlytheE 's SDK session, is there another?

Thanks once again!


Hi @c2willis,


1. I spoke with one of the developers of SnakePlane, and he said that there are actually typically improvements in processing time for tools built with SnakePlane versus those built without.


2. You got it! Just build all of your tools into a shared directory, and then package that directory. The tools will all be included in the resulting .yxi. As a side note, there is some funky behavior with using multiple SDK tools on a single canvas in 2019.1. This is set to be resolved in 2019.2, and also does not occur in 2018.4.


3. Have you registered for BUILD2? It's on Tuesday, and people will be developing and analyzing all sorts of neat things. There is a specific SDK track, where you can compete (alone or with a team) to build an awesome Python SDK tool. The event is staffed by Alteryx Employees to provide help and answer questions - this might be exactly what you are looking for. I hope to see you there!


I am so glad you found the tutorial valuable! I am excited to see/hear/read about what you create with SnakePlane!

11 - Bolide

Hey @SydneyF ,


That's good to hear, thank you!


Shoot, I think I registered for a platform training on Tuesday afternoon. I'll have to check my registration tomorrow and see what I want to/can do.



8 - Asteroid

I've built a couple custom tools from scratch, just starting in on SnakePlane.


It might be obvious to others, but what's the difference between a Batch, Source and Stream tool as it pertains to the Python SDK? (ie - the @factory.process_data() modes)


Hi @carl_steinhilber,


Mode allows us to specify how we want the plugin to operate in terms of bringing in data. Batch mode brings in all of the data being fed into the tool at once, which is handy if you are building a tool that needs to see all records simultaneously (like a predictive tool). Stream mode brings in the input records a single row at a time (i.e., bring in a row, do the process defined by the script, write the output to the Engine, repeat with the next row). Source mode is for when the tool doesn't expect an input stream of data at all (e.g., an input tool). 


You might also find the documentation on the GitHub page helpful for understanding the difference. 


Hope this helps!



8 - Asteroid

Perfect! Thank you Sydney, that's an excellent, clear description. I appreciate it.