aws.transcribe.Vocabulary

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.s3.BucketV2("example", {
    bucket: "example-vocab-123",
    forceDestroy: true,
});
const object = new aws.s3.BucketObjectv2("object", {
    bucket: example.id,
    key: "transcribe/test1.txt",
    source: new pulumi.asset.FileAsset("test.txt"),
});
const exampleVocabulary = new aws.transcribe.Vocabulary("example", {
    vocabularyName: "example",
    languageCode: "en-US",
    vocabularyFileUri: pulumi.interpolate`s3://${example.id}/${object.key}`,
    tags: {
        tag1: "value1",
        tag2: "value3",
    },
}, {
    dependsOn: [object],
});

import pulumi
import pulumi_aws as aws

example = aws.s3.BucketV2("example",
    bucket="example-vocab-123",
    force_destroy=True)
object = aws.s3.BucketObjectv2("object",
    bucket=example.id,
    key="transcribe/test1.txt",
    source=pulumi.FileAsset("test.txt"))
example_vocabulary = aws.transcribe.Vocabulary("example",
    vocabulary_name="example",
    language_code="en-US",
    vocabulary_file_uri=pulumi.Output.all(
        id=example.id,
        key=object.key
).apply(lambda resolved_outputs: f"s3://{resolved_outputs['id']}/{resolved_outputs['key']}")
,
    tags={
        "tag1": "value1",
        "tag2": "value3",
    },
    opts = pulumi.ResourceOptions(depends_on=[object]))

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/transcribe"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := s3.NewBucketV2(ctx, "example", &s3.BucketV2Args{
			Bucket:       pulumi.String("example-vocab-123"),
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		object, err := s3.NewBucketObjectv2(ctx, "object", &s3.BucketObjectv2Args{
			Bucket: example.ID(),
			Key:    pulumi.String("transcribe/test1.txt"),
			Source: pulumi.NewFileAsset("test.txt"),
		})
		if err != nil {
			return err
		}
		_, err = transcribe.NewVocabulary(ctx, "example", &transcribe.VocabularyArgs{
			VocabularyName: pulumi.String("example"),
			LanguageCode:   pulumi.String("en-US"),
			VocabularyFileUri: pulumi.All(example.ID(), object.Key).ApplyT(func(_args []interface{}) (string, error) {
				id := _args[0].(string)
				key := _args[1].(string)
				return fmt.Sprintf("s3://%v/%v", id, key), nil
			}).(pulumi.StringOutput),
			Tags: pulumi.StringMap{
				"tag1": pulumi.String("value1"),
				"tag2": pulumi.String("value3"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			object,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Aws.S3.BucketV2("example", new()
    {
        Bucket = "example-vocab-123",
        ForceDestroy = true,
    });

    var @object = new Aws.S3.BucketObjectv2("object", new()
    {
        Bucket = example.Id,
        Key = "transcribe/test1.txt",
        Source = new FileAsset("test.txt"),
    });

    var exampleVocabulary = new Aws.Transcribe.Vocabulary("example", new()
    {
        VocabularyName = "example",
        LanguageCode = "en-US",
        VocabularyFileUri = Output.Tuple(example.Id, @object.Key).Apply(values =>
        {
            var id = values.Item1;
            var key = values.Item2;
            return $"s3://{id}/{key}";
        }),
        Tags = 
        {
            { "tag1", "value1" },
            { "tag2", "value3" },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            @object,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketV2;
import com.pulumi.aws.s3.BucketV2Args;
import com.pulumi.aws.s3.BucketObjectv2;
import com.pulumi.aws.s3.BucketObjectv2Args;
import com.pulumi.aws.transcribe.Vocabulary;
import com.pulumi.aws.transcribe.VocabularyArgs;
import com.pulumi.resources.CustomResourceOptions;
import com.pulumi.asset.FileAsset;
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 example = new BucketV2("example", BucketV2Args.builder()
            .bucket("example-vocab-123")
            .forceDestroy(true)
            .build());

        var object = new BucketObjectv2("object", BucketObjectv2Args.builder()
            .bucket(example.id())
            .key("transcribe/test1.txt")
            .source(new FileAsset("test.txt"))
            .build());

        var exampleVocabulary = new Vocabulary("exampleVocabulary", VocabularyArgs.builder()
            .vocabularyName("example")
            .languageCode("en-US")
            .vocabularyFileUri(Output.tuple(example.id(), object.key()).applyValue(values -> {
                var id = values.t1;
                var key = values.t2;
                return String.format("s3://%s/%s", id,key);
            }))
            .tags(Map.ofEntries(
                Map.entry("tag1", "value1"),
                Map.entry("tag2", "value3")
            ))
            .build(), CustomResourceOptions.builder()
                .dependsOn(object)
                .build());

    }
}

resources:
  example:
    type: aws:s3:BucketV2
    properties:
      bucket: example-vocab-123
      forceDestroy: true
  object:
    type: aws:s3:BucketObjectv2
    properties:
      bucket: ${example.id}
      key: transcribe/test1.txt
      source:
        fn::FileAsset: test.txt
  exampleVocabulary:
    type: aws:transcribe:Vocabulary
    name: example
    properties:
      vocabularyName: example
      languageCode: en-US
      vocabularyFileUri: s3://${example.id}/${object.key}
      tags:
        tag1: value1
        tag2: value3
    options:
      dependson:
        - ${object}

var awsVocabularyResource = new Aws.Transcribe.Vocabulary("awsVocabularyResource", new()
{
    LanguageCode = "string",
    VocabularyName = "string",
    Phrases = new[]
    {
        "string",
    },
    Tags = 
    {
        { "string", "string" },
    },
    VocabularyFileUri = "string",
});

example, err := transcribe.NewVocabulary(ctx, "awsVocabularyResource", &transcribe.VocabularyArgs{
	LanguageCode:   pulumi.String("string"),
	VocabularyName: pulumi.String("string"),
	Phrases: pulumi.StringArray{
		pulumi.String("string"),
	},
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	VocabularyFileUri: pulumi.String("string"),
})

var awsVocabularyResource = new Vocabulary("awsVocabularyResource", VocabularyArgs.builder()
    .languageCode("string")
    .vocabularyName("string")
    .phrases("string")
    .tags(Map.of("string", "string"))
    .vocabularyFileUri("string")
    .build());

aws_vocabulary_resource = aws.transcribe.Vocabulary("awsVocabularyResource",
    language_code="string",
    vocabulary_name="string",
    phrases=["string"],
    tags={
        "string": "string",
    },
    vocabulary_file_uri="string")

const awsVocabularyResource = new aws.transcribe.Vocabulary("awsVocabularyResource", {
    languageCode: "string",
    vocabularyName: "string",
    phrases: ["string"],
    tags: {
        string: "string",
    },
    vocabularyFileUri: "string",
});

type: aws:transcribe:Vocabulary
properties:
    languageCode: string
    phrases:
        - string
    tags:
        string: string
    vocabularyFileUri: string
    vocabularyName: string