com.pulumi.awsnative.comprehend.kotlin.inputs.DocumentClassifierInputDataConfigArgs.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of pulumi-aws-native-kotlin Show documentation
Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.
There is a newer version: 1.24.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.awsnative.comprehend.kotlin.inputs

import com.pulumi.awsnative.comprehend.inputs.DocumentClassifierInputDataConfigArgs.builder
import com.pulumi.awsnative.comprehend.kotlin.enums.DocumentClassifierInputDataConfigDataFormat
import com.pulumi.awsnative.comprehend.kotlin.enums.DocumentClassifierInputDataConfigDocumentType
import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 *
 * @property augmentedManifests A list of augmented manifest files that provide training data for your custom model. An augmented manifest file is a labeled dataset that is produced by Amazon SageMaker Ground Truth.
 * This parameter is required if you set `DataFormat` to `AUGMENTED_MANIFEST` .
 * @property dataFormat The format of your training data:
 * - `COMPREHEND_CSV` : A two-column CSV file, where labels are provided in the first column, and documents are provided in the second. If you use this value, you must provide the `S3Uri` parameter in your request.
 * - `AUGMENTED_MANIFEST` : A labeled dataset that is produced by Amazon SageMaker Ground Truth. This file is in JSON lines format. Each line is a complete JSON object that contains a training document and its associated labels.
 * If you use this value, you must provide the `AugmentedManifests` parameter in your request.
 * If you don't specify a value, Amazon Comprehend uses `COMPREHEND_CSV` as the default.
 * @property documentReaderConfig
 * @property documentType The type of input documents for training the model. Provide plain-text documents to create a plain-text model, and provide semi-structured documents to create a native document model.
 * @property documents The S3 location of the training documents. This parameter is required in a request to create a native document model.
 * @property labelDelimiter Indicates the delimiter used to separate each label for training a multi-label classifier. The default delimiter between labels is a pipe (|). You can use a different character as a delimiter (if it's an allowed character) by specifying it under Delimiter for labels. If the training documents use a delimiter other than the default or the delimiter you specify, the labels on that line will be combined to make a single unique label, such as LABELLABELLABEL.
 * @property s3Uri The Amazon S3 URI for the input data. The S3 bucket must be in the same Region as the API endpoint that you are calling. The URI can point to a single input file or it can provide the prefix for a collection of input files.
 * For example, if you use the URI `S3://bucketName/prefix` , if the prefix is a single file, Amazon Comprehend uses that file as input. If more than one file begins with the prefix, Amazon Comprehend uses all of them as input.
 * This parameter is required if you set `DataFormat` to `COMPREHEND_CSV` .
 * @property testS3Uri This specifies the Amazon S3 location that contains the test annotations for the document classifier. The URI must be in the same AWS Region as the API endpoint that you are calling.
 */
public data class DocumentClassifierInputDataConfigArgs(
    public val augmentedManifests: Output>? =
        null,
    public val dataFormat: Output? = null,
    public val documentReaderConfig: Output? = null,
    public val documentType: Output? = null,
    public val documents: Output? = null,
    public val labelDelimiter: Output? = null,
    public val s3Uri: Output? = null,
    public val testS3Uri: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.awsnative.comprehend.inputs.DocumentClassifierInputDataConfigArgs =
        com.pulumi.awsnative.comprehend.inputs.DocumentClassifierInputDataConfigArgs.builder()
            .augmentedManifests(
                augmentedManifests?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 -> args0.toJava() })
                    })
                }),
            )
            .dataFormat(dataFormat?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .documentReaderConfig(
                documentReaderConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .documentType(documentType?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .documents(documents?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .labelDelimiter(labelDelimiter?.applyValue({ args0 -> args0 }))
            .s3Uri(s3Uri?.applyValue({ args0 -> args0 }))
            .testS3Uri(testS3Uri?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [DocumentClassifierInputDataConfigArgs].
 */
@PulumiTagMarker
public class DocumentClassifierInputDataConfigArgsBuilder internal constructor() {
    private var augmentedManifests: Output>? =
        null

    private var dataFormat: Output? = null

    private var documentReaderConfig: Output? = null

    private var documentType: Output? = null

    private var documents: Output? = null

    private var labelDelimiter: Output? = null

    private var s3Uri: Output? = null

    private var testS3Uri: Output? = null

    /**
     * @param value A list of augmented manifest files that provide training data for your custom model. An augmented manifest file is a labeled dataset that is produced by Amazon SageMaker Ground Truth.
     * This parameter is required if you set `DataFormat` to `AUGMENTED_MANIFEST` .
     */
    @JvmName("dvhxdtavrknncepi")
    public suspend fun augmentedManifests(`value`: Output>) {
        this.augmentedManifests = value
    }

    @JvmName("nvfrxabytqcrwkgo")
    public suspend fun augmentedManifests(vararg values: Output) {
        this.augmentedManifests = Output.all(values.asList())
    }

    /**
     * @param values A list of augmented manifest files that provide training data for your custom model. An augmented manifest file is a labeled dataset that is produced by Amazon SageMaker Ground Truth.
     * This parameter is required if you set `DataFormat` to `AUGMENTED_MANIFEST` .
     */
    @JvmName("xkkadysipyqpidae")
    public suspend fun augmentedManifests(values: List>) {
        this.augmentedManifests = Output.all(values)
    }

    /**
     * @param value The format of your training data:
     * - `COMPREHEND_CSV` : A two-column CSV file, where labels are provided in the first column, and documents are provided in the second. If you use this value, you must provide the `S3Uri` parameter in your request.
     * - `AUGMENTED_MANIFEST` : A labeled dataset that is produced by Amazon SageMaker Ground Truth. This file is in JSON lines format. Each line is a complete JSON object that contains a training document and its associated labels.
     * If you use this value, you must provide the `AugmentedManifests` parameter in your request.
     * If you don't specify a value, Amazon Comprehend uses `COMPREHEND_CSV` as the default.
     */
    @JvmName("gbqwcfwbjujfhodv")
    public suspend fun dataFormat(`value`: Output) {
        this.dataFormat = value
    }

    /**
     * @param value
     */
    @JvmName("ttgfdaxmhxqtkkvb")
    public suspend fun documentReaderConfig(`value`: Output) {
        this.documentReaderConfig = value
    }

    /**
     * @param value The type of input documents for training the model. Provide plain-text documents to create a plain-text model, and provide semi-structured documents to create a native document model.
     */
    @JvmName("fqmircpvxftcsqpj")
    public suspend fun documentType(`value`: Output) {
        this.documentType = value
    }

    /**
     * @param value The S3 location of the training documents. This parameter is required in a request to create a native document model.
     */
    @JvmName("sbayvgsileouykoi")
    public suspend fun documents(`value`: Output) {
        this.documents = value
    }

    /**
     * @param value Indicates the delimiter used to separate each label for training a multi-label classifier. The default delimiter between labels is a pipe (|). You can use a different character as a delimiter (if it's an allowed character) by specifying it under Delimiter for labels. If the training documents use a delimiter other than the default or the delimiter you specify, the labels on that line will be combined to make a single unique label, such as LABELLABELLABEL.
     */
    @JvmName("qrmhbjmqlqgobdli")
    public suspend fun labelDelimiter(`value`: Output) {
        this.labelDelimiter = value
    }

    /**
     * @param value The Amazon S3 URI for the input data. The S3 bucket must be in the same Region as the API endpoint that you are calling. The URI can point to a single input file or it can provide the prefix for a collection of input files.
     * For example, if you use the URI `S3://bucketName/prefix` , if the prefix is a single file, Amazon Comprehend uses that file as input. If more than one file begins with the prefix, Amazon Comprehend uses all of them as input.
     * This parameter is required if you set `DataFormat` to `COMPREHEND_CSV` .
     */
    @JvmName("frooafpmjaghjicl")
    public suspend fun s3Uri(`value`: Output) {
        this.s3Uri = value
    }

    /**
     * @param value This specifies the Amazon S3 location that contains the test annotations for the document classifier. The URI must be in the same AWS Region as the API endpoint that you are calling.
     */
    @JvmName("eutsnwhvtbpkpuon")
    public suspend fun testS3Uri(`value`: Output) {
        this.testS3Uri = value
    }

    /**
     * @param value A list of augmented manifest files that provide training data for your custom model. An augmented manifest file is a labeled dataset that is produced by Amazon SageMaker Ground Truth.
     * This parameter is required if you set `DataFormat` to `AUGMENTED_MANIFEST` .
     */
    @JvmName("bqbmvqssodebewfy")
    public suspend fun augmentedManifests(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.augmentedManifests = mapped
    }

    /**
     * @param argument A list of augmented manifest files that provide training data for your custom model. An augmented manifest file is a labeled dataset that is produced by Amazon SageMaker Ground Truth.
     * This parameter is required if you set `DataFormat` to `AUGMENTED_MANIFEST` .
     */
    @JvmName("bokqsasiojjbxvep")
    public suspend fun augmentedManifests(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            DocumentClassifierAugmentedManifestsListItemArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.augmentedManifests = mapped
    }

    /**
     * @param argument A list of augmented manifest files that provide training data for your custom model. An augmented manifest file is a labeled dataset that is produced by Amazon SageMaker Ground Truth.
     * This parameter is required if you set `DataFormat` to `AUGMENTED_MANIFEST` .
     */
    @JvmName("tqeytxjgmswmhljc")
    public suspend fun augmentedManifests(vararg argument: suspend DocumentClassifierAugmentedManifestsListItemArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            DocumentClassifierAugmentedManifestsListItemArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.augmentedManifests = mapped
    }

    /**
     * @param argument A list of augmented manifest files that provide training data for your custom model. An augmented manifest file is a labeled dataset that is produced by Amazon SageMaker Ground Truth.
     * This parameter is required if you set `DataFormat` to `AUGMENTED_MANIFEST` .
     */
    @JvmName("ipvhxkcncnjsecyf")
    public suspend fun augmentedManifests(argument: suspend DocumentClassifierAugmentedManifestsListItemArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            DocumentClassifierAugmentedManifestsListItemArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.augmentedManifests = mapped
    }

    /**
     * @param values A list of augmented manifest files that provide training data for your custom model. An augmented manifest file is a labeled dataset that is produced by Amazon SageMaker Ground Truth.
     * This parameter is required if you set `DataFormat` to `AUGMENTED_MANIFEST` .
     */
    @JvmName("vfqqxfrdqarmfmxm")
    public suspend fun augmentedManifests(vararg values: DocumentClassifierAugmentedManifestsListItemArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.augmentedManifests = mapped
    }

    /**
     * @param value The format of your training data:
     * - `COMPREHEND_CSV` : A two-column CSV file, where labels are provided in the first column, and documents are provided in the second. If you use this value, you must provide the `S3Uri` parameter in your request.
     * - `AUGMENTED_MANIFEST` : A labeled dataset that is produced by Amazon SageMaker Ground Truth. This file is in JSON lines format. Each line is a complete JSON object that contains a training document and its associated labels.
     * If you use this value, you must provide the `AugmentedManifests` parameter in your request.
     * If you don't specify a value, Amazon Comprehend uses `COMPREHEND_CSV` as the default.
     */
    @JvmName("wnnsgrtemygktkhv")
    public suspend fun dataFormat(`value`: DocumentClassifierInputDataConfigDataFormat?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.dataFormat = mapped
    }

    /**
     * @param value
     */
    @JvmName("vpkxakwoewqxsqsk")
    public suspend fun documentReaderConfig(`value`: DocumentClassifierDocumentReaderConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.documentReaderConfig = mapped
    }

    /**
     * @param argument
     */
    @JvmName("fdknvbnsekaforef")
    public suspend fun documentReaderConfig(argument: suspend DocumentClassifierDocumentReaderConfigArgsBuilder.() -> Unit) {
        val toBeMapped = DocumentClassifierDocumentReaderConfigArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.documentReaderConfig = mapped
    }

    /**
     * @param value The type of input documents for training the model. Provide plain-text documents to create a plain-text model, and provide semi-structured documents to create a native document model.
     */
    @JvmName("whotusgcasdnutwh")
    public suspend fun documentType(`value`: DocumentClassifierInputDataConfigDocumentType?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.documentType = mapped
    }

    /**
     * @param value The S3 location of the training documents. This parameter is required in a request to create a native document model.
     */
    @JvmName("aljabrkbcfiowatu")
    public suspend fun documents(`value`: DocumentClassifierDocumentsArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.documents = mapped
    }

    /**
     * @param argument The S3 location of the training documents. This parameter is required in a request to create a native document model.
     */
    @JvmName("bdcqfsexgrsmbpex")
    public suspend fun documents(argument: suspend DocumentClassifierDocumentsArgsBuilder.() -> Unit) {
        val toBeMapped = DocumentClassifierDocumentsArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.documents = mapped
    }

    /**
     * @param value Indicates the delimiter used to separate each label for training a multi-label classifier. The default delimiter between labels is a pipe (|). You can use a different character as a delimiter (if it's an allowed character) by specifying it under Delimiter for labels. If the training documents use a delimiter other than the default or the delimiter you specify, the labels on that line will be combined to make a single unique label, such as LABELLABELLABEL.
     */
    @JvmName("giwyrujyfvsdncpe")
    public suspend fun labelDelimiter(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.labelDelimiter = mapped
    }

    /**
     * @param value The Amazon S3 URI for the input data. The S3 bucket must be in the same Region as the API endpoint that you are calling. The URI can point to a single input file or it can provide the prefix for a collection of input files.
     * For example, if you use the URI `S3://bucketName/prefix` , if the prefix is a single file, Amazon Comprehend uses that file as input. If more than one file begins with the prefix, Amazon Comprehend uses all of them as input.
     * This parameter is required if you set `DataFormat` to `COMPREHEND_CSV` .
     */
    @JvmName("qkrnpbvnqmudvigb")
    public suspend fun s3Uri(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.s3Uri = mapped
    }

    /**
     * @param value This specifies the Amazon S3 location that contains the test annotations for the document classifier. The URI must be in the same AWS Region as the API endpoint that you are calling.
     */
    @JvmName("rubeogyahoquavgr")
    public suspend fun testS3Uri(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.testS3Uri = mapped
    }

    internal fun build(): DocumentClassifierInputDataConfigArgs =
        DocumentClassifierInputDataConfigArgs(
            augmentedManifests = augmentedManifests,
            dataFormat = dataFormat,
            documentReaderConfig = documentReaderConfig,
            documentType = documentType,
            documents = documents,
            labelDelimiter = labelDelimiter,
            s3Uri = s3Uri,
            testS3Uri = testS3Uri,
        )
}