azure-native.discovery.Tool

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var tool = new AzureNative.Discovery.Tool("tool", new()
    {
        Location = "uksouth",
        Properties = new AzureNative.Discovery.Inputs.ToolPropertiesArgs
        {
            DefinitionContent = new Dictionary<string, object?>
            {
                ["actions"] = new[]
                {
                    new Dictionary<string, object?>
                    {
                        ["command"] = "python3 submit_dft.py ",
                        ["description"] = "Optimize geometry of 'xyz's from the input data asset. This is a prerequisite for all other discovery computations.",
                        ["environment_variables"] = new[]
                        {
                            new Dictionary<string, object?>
                            {
                                ["name"] = "OUTPUT_DIRECTORY_PATH",
                                ["value"] = "{{ outputDataAssetId }}",
                            },
                        },
                        ["input_schema"] = new Dictionary<string, object?>
                        {
                            ["properties"] = new Dictionary<string, object?>
                            {
                                ["basisSet"] = new Dictionary<string, object?>
                                {
                                    ["description"] = "Basis set. Must be one of the supported basis sets (e.g., def2-svp, def2-tzvp).",
                                    ["type"] = "string",
                                },
                                ["inputDataAssetId"] = new Dictionary<string, object?>
                                {
                                    ["description"] = "Identifier of the input data asset",
                                    ["type"] = "string",
                                },
                                ["outputDataAssetId"] = new Dictionary<string, object?>
                                {
                                    ["description"] = "Identifier to use for the new output data asset which will be created.",
                                    ["type"] = "string",
                                },
                                ["xyzColumnName"] = new Dictionary<string, object?>
                                {
                                    ["description"] = "Column containing xyz data within the input data table asset",
                                    ["type"] = "string",
                                },
                            },
                            ["required"] = new[]
                            {
                                "inputDataAssetId",
                                "xyzColumnName",
                            },
                            ["type"] = "object",
                        },
                        ["name"] = "GeometryOptimization",
                    },
                },
                ["description"] = "Advanced DFT computational tools for molecular geometry optimization and property calculations",
                ["name"] = "discovery",
                ["tool_id"] = "discovery-m1",
            },
            EnvironmentVariables = 
            {
                { "key5460", "xtjzjghbist" },
            },
            Version = "sjepxewtq",
        },
        ResourceGroupName = "rgdiscovery",
        Tags = 
        {
            { "key2611", "cgsblxvyzevbd" },
        },
        ToolName = "b5d4239f788c20b58b",
    });

});

package main

import (
	discovery "github.com/pulumi/pulumi-azure-native-sdk/discovery/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := discovery.NewTool(ctx, "tool", &discovery.ToolArgs{
			Location: pulumi.String("uksouth"),
			Properties: &discovery.ToolPropertiesArgs{
				DefinitionContent: pulumi.Any(map[string]interface{}{
					"actions": []map[string]interface{}{
						map[string]interface{}{
							"command":     "python3 submit_dft.py ",
							"description": "Optimize geometry of 'xyz's from the input data asset. This is a prerequisite for all other discovery computations.",
							"environment_variables": []map[string]interface{}{
								map[string]interface{}{
									"name":  "OUTPUT_DIRECTORY_PATH",
									"value": "{{ outputDataAssetId }}",
								},
							},
							"input_schema": map[string]interface{}{
								"properties": map[string]interface{}{
									"basisSet": map[string]interface{}{
										"description": "Basis set. Must be one of the supported basis sets (e.g., def2-svp, def2-tzvp).",
										"type":        "string",
									},
									"inputDataAssetId": map[string]interface{}{
										"description": "Identifier of the input data asset",
										"type":        "string",
									},
									"outputDataAssetId": map[string]interface{}{
										"description": "Identifier to use for the new output data asset which will be created.",
										"type":        "string",
									},
									"xyzColumnName": map[string]interface{}{
										"description": "Column containing xyz data within the input data table asset",
										"type":        "string",
									},
								},
								"required": []string{
									"inputDataAssetId",
									"xyzColumnName",
								},
								"type": "object",
							},
							"name": "GeometryOptimization",
						},
					},
					"description": "Advanced DFT computational tools for molecular geometry optimization and property calculations",
					"name":        "discovery",
					"tool_id":     "discovery-m1",
				}),
				EnvironmentVariables: pulumi.StringMap{
					"key5460": pulumi.String("xtjzjghbist"),
				},
				Version: pulumi.String("sjepxewtq"),
			},
			ResourceGroupName: pulumi.String("rgdiscovery"),
			Tags: pulumi.StringMap{
				"key2611": pulumi.String("cgsblxvyzevbd"),
			},
			ToolName: pulumi.String("b5d4239f788c20b58b"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.discovery.Tool;
import com.pulumi.azurenative.discovery.ToolArgs;
import com.pulumi.azurenative.discovery.inputs.ToolPropertiesArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var tool = new Tool("tool", ToolArgs.builder()
            .location("uksouth")
            .properties(ToolPropertiesArgs.builder()
                .definitionContent(Map.ofEntries(
                    Map.entry("actions", Map.ofEntries(
                        Map.entry("command", "python3 submit_dft.py "),
                        Map.entry("description", "Optimize geometry of 'xyz's from the input data asset. This is a prerequisite for all other discovery computations."),
                        Map.entry("environment_variables", Map.ofEntries(
                            Map.entry("name", "OUTPUT_DIRECTORY_PATH"),
                            Map.entry("value", "{{ outputDataAssetId }}")
                        )),
                        Map.entry("input_schema", Map.ofEntries(
                            Map.entry("properties", Map.ofEntries(
                                Map.entry("basisSet", Map.ofEntries(
                                    Map.entry("description", "Basis set. Must be one of the supported basis sets (e.g., def2-svp, def2-tzvp)."),
                                    Map.entry("type", "string")
                                )),
                                Map.entry("inputDataAssetId", Map.ofEntries(
                                    Map.entry("description", "Identifier of the input data asset"),
                                    Map.entry("type", "string")
                                )),
                                Map.entry("outputDataAssetId", Map.ofEntries(
                                    Map.entry("description", "Identifier to use for the new output data asset which will be created."),
                                    Map.entry("type", "string")
                                )),
                                Map.entry("xyzColumnName", Map.ofEntries(
                                    Map.entry("description", "Column containing xyz data within the input data table asset"),
                                    Map.entry("type", "string")
                                ))
                            )),
                            Map.entry("required",                             
                                "inputDataAssetId",
                                "xyzColumnName"),
                            Map.entry("type", "object")
                        )),
                        Map.entry("name", "GeometryOptimization")
                    )),
                    Map.entry("description", "Advanced DFT computational tools for molecular geometry optimization and property calculations"),
                    Map.entry("name", "discovery"),
                    Map.entry("tool_id", "discovery-m1")
                ))
                .environmentVariables(Map.of("key5460", "xtjzjghbist"))
                .version("sjepxewtq")
                .build())
            .resourceGroupName("rgdiscovery")
            .tags(Map.of("key2611", "cgsblxvyzevbd"))
            .toolName("b5d4239f788c20b58b")
            .build());

    }
}

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const tool = new azure_native.discovery.Tool("tool", {
    location: "uksouth",
    properties: {
        definitionContent: {
            actions: [{
                command: "python3 submit_dft.py ",
                description: "Optimize geometry of 'xyz's from the input data asset. This is a prerequisite for all other discovery computations.",
                environment_variables: [{
                    name: "OUTPUT_DIRECTORY_PATH",
                    value: "{{ outputDataAssetId }}",
                }],
                input_schema: {
                    properties: {
                        basisSet: {
                            description: "Basis set. Must be one of the supported basis sets (e.g., def2-svp, def2-tzvp).",
                            type: "string",
                        },
                        inputDataAssetId: {
                            description: "Identifier of the input data asset",
                            type: "string",
                        },
                        outputDataAssetId: {
                            description: "Identifier to use for the new output data asset which will be created.",
                            type: "string",
                        },
                        xyzColumnName: {
                            description: "Column containing xyz data within the input data table asset",
                            type: "string",
                        },
                    },
                    required: [
                        "inputDataAssetId",
                        "xyzColumnName",
                    ],
                    type: "object",
                },
                name: "GeometryOptimization",
            }],
            description: "Advanced DFT computational tools for molecular geometry optimization and property calculations",
            name: "discovery",
            tool_id: "discovery-m1",
        },
        environmentVariables: {
            key5460: "xtjzjghbist",
        },
        version: "sjepxewtq",
    },
    resourceGroupName: "rgdiscovery",
    tags: {
        key2611: "cgsblxvyzevbd",
    },
    toolName: "b5d4239f788c20b58b",
});

import pulumi
import pulumi_azure_native as azure_native

tool = azure_native.discovery.Tool("tool",
    location="uksouth",
    properties={
        "definition_content": {
            "actions": [{
                "command": "python3 submit_dft.py ",
                "description": "Optimize geometry of 'xyz's from the input data asset. This is a prerequisite for all other discovery computations.",
                "environment_variables": [{
                    "name": "OUTPUT_DIRECTORY_PATH",
                    "value": "{{ outputDataAssetId }}",
                }],
                "input_schema": {
                    "properties": {
                        "basisSet": {
                            "description": "Basis set. Must be one of the supported basis sets (e.g., def2-svp, def2-tzvp).",
                            "type": "string",
                        },
                        "inputDataAssetId": {
                            "description": "Identifier of the input data asset",
                            "type": "string",
                        },
                        "outputDataAssetId": {
                            "description": "Identifier to use for the new output data asset which will be created.",
                            "type": "string",
                        },
                        "xyzColumnName": {
                            "description": "Column containing xyz data within the input data table asset",
                            "type": "string",
                        },
                    },
                    "required": [
                        "inputDataAssetId",
                        "xyzColumnName",
                    ],
                    "type": "object",
                },
                "name": "GeometryOptimization",
            }],
            "description": "Advanced DFT computational tools for molecular geometry optimization and property calculations",
            "name": "discovery",
            "tool_id": "discovery-m1",
        },
        "environment_variables": {
            "key5460": "xtjzjghbist",
        },
        "version": "sjepxewtq",
    },
    resource_group_name="rgdiscovery",
    tags={
        "key2611": "cgsblxvyzevbd",
    },
    tool_name="b5d4239f788c20b58b")

resources:
  tool:
    type: azure-native:discovery:Tool
    properties:
      location: uksouth
      properties:
        definitionContent:
          actions:
            - command: 'python3 submit_dft.py '
              description: Optimize geometry of 'xyz's from the input data asset. This is a prerequisite for all other discovery computations.
              environment_variables:
                - name: OUTPUT_DIRECTORY_PATH
                  value: '{{ outputDataAssetId }}'
              input_schema:
                properties:
                  basisSet:
                    description: Basis set. Must be one of the supported basis sets (e.g., def2-svp, def2-tzvp).
                    type: string
                  inputDataAssetId:
                    description: Identifier of the input data asset
                    type: string
                  outputDataAssetId:
                    description: Identifier to use for the new output data asset which will be created.
                    type: string
                  xyzColumnName:
                    description: Column containing xyz data within the input data table asset
                    type: string
                required:
                  - inputDataAssetId
                  - xyzColumnName
                type: object
              name: GeometryOptimization
          description: Advanced DFT computational tools for molecular geometry optimization and property calculations
          name: discovery
          tool_id: discovery-m1
        environmentVariables:
          key5460: xtjzjghbist
        version: sjepxewtq
      resourceGroupName: rgdiscovery
      tags:
        key2611: cgsblxvyzevbd
      toolName: b5d4239f788c20b58b