Set user input as path for saving Python toolbox results

Question

I created a Python toolbox to run in ArcGIS Pro 3.0. I wish to save toolbox results in another geodatabase than the one by default, which contains input data.

This toolbox will be run by several users so I can't write the full path, and depending on the project the user is working on, I wish she/he could choose to save results in a geodatabase created by her/him, meaning with a customized name.

I wish the path and names of the results (defined as parameters), are pre-filled, so the user doesn't need to choose her/himself.

Below is a part of the script

import arcpy
import os

class Toolbox(object):
    def __init__(self):
        """Define the toolbox (the name of the toolbox is the name of the
        .pyt file)."""
        self.label = "StatisticsToolbox"
        self.alias = "StatisticsToolbox"

        # 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 = "Statistics of Subsistence Activities by Type in a Defined Area"
        self.description = "This tool calculates the total surface of each type of subsistence activities \
        in an area defined by the user using a polygon shapefile as parameter"
        self.canRunInBackground = False


    def getParameterInfo(self):
        """Define parameter definitions"""

        ''' Input parameters '''
        # Parameter 0: Subsistence layer
        param0 = arcpy.Parameter(
            displayName="Input layer of subsistence activities",
            name="in_features",
            datatype="GPFeatureLayer",
            parameterType="Required",
            direction="Input"
            )
        param0.value = "Interne\\Activite_subsistance"

        # Parameter 1: Clip feature
        param1 = arcpy.Parameter(
            displayName="Study area used for clipping",
            name="clip_features",
            datatype="GPFeatureLayer",
            parameterType="Required",
            direction="Input"
            )
        param1.value = "studyArea_poly"

        # Parameter 2: Output gdb
        param2 = arcpy.Parameter(
            displayName="Output Geodatabase",
            name="out_gdb",
            datatype="DEWorkspace",
            parameterType="Required",
            direction="Input"
            )
        param2.value = "ProjetXYZ.gdb"

        ''' Output parameters '''
        # Parameter 3: Output clip
        param3 = arcpy.Parameter(
            displayName="Clipped layer name",
            name="out_clip_name",
            datatype="GPFeatureLayer",
            parameterType="Required",
            direction="Output"
            )
        param3.value = "clip"

        params = [param0, param1, param2, param3]


        return params

    def isLicensed(self):
        """Set whether tool is licensed to execute."""
        return True

    def updateParameters(self, params):
        """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, params):
        """Modify the messages created by internal validation for each tool
        parameter.  This method is called after internal validation."""
        return

    def execute(self, params, messages):
        """The source code of the tool."""

        # List parameters
        inFeatures = params[0].valueAsText
        clipFeatures = params[1].valueAsText
        outGDB = params[2].valueAsText
        outCLIP = params[3].valueAsText

        # Process: Feature Class To Feature Class (conversion)
        Activite_subsistance_gdb = arcpy.conversion.FeatureClassToFeatureClass(
                                                                                in_features=inFeatures,
                                                                                out_path=outGDB,
                                                                                out_name="Activite_subsistance_gdb"
                                                                                )[0]


        # Process: CLIP SUBSI (Clip) (analysis)
        arcpy.analysis.Clip(
                                in_features=Activite_subsistance_gdb,
                                clip_features=clipFeatures,
                                out_feature_class=outCLIP)

        return

    def postExecute(self, params):
        """This method takes place after outputs are processed and
        added to the display."""
        return

As the default gdb is the geodatabase containing input data, parameters 0 and 1 are correctly found by the tool.

The user will have created a gdb for the project (parameter 2) in the same directory as the default geodatabase.

But how can I specify the path for parameter 3, based on the value of parameter 2 once defined by the user?

I tried to update param3 value in the function updateParameters, using param2 value.

param3.value = os.path.join(os.path.dirname(__file__), params[2].valueAsText,'clip.shp')

but I get the error The name contains invalid characters.

Answer 1

@Vince’s comment helped me find 2 problems which were the extension, and os.path.dirname(__file__), which is the path of the toolbox instead of the workspace as I first thought

I made the correction in updateParameters, and it works great :)

    def updateParameters(self, params):
        """Modify the values and properties of parameters before internal
        validation is performed.  This method is called whenever a parameter
        has been changed."""
        params[3].value = os.path.join(params[2].valueAsText, 'clip')
        return