create_glossary_term async ¶

async def create_glossary_term(
    self,
    domain_identifier: "capo_datazone.types.domain_id.DomainId",
    glossary_identifier: "capo_datazone.types.glossary_term_id.GlossaryTermId",
    name: "capo_datazone.types.glossary_term_name.GlossaryTermName",
    *,
    config_overrides: Optional[AsyncDataZoneClientConfig] = None,
    status: Optional[
        "capo_datazone.types.glossary_term_status.GlossaryTermStatus"
    ] = None,
    short_description: Optional[
        "capo_datazone.types.short_description.ShortDescription"
    ] = None,
    long_description: Optional[
        "capo_datazone.types.long_description.LongDescription"
    ] = None,
    term_relations: Optional[
        "capo_datazone.types.term_relations.TermRelations"
    ] = None,
    client_token: Optional["capo_datazone.types.client_token.ClientToken"] = None,
) -> "capo_datazone.types.create_glossary_term_output.CreateGlossaryTermOutput":
    """<p>Creates a business glossary term.</p> <p>A glossary term represents an individual entry within the Amazon DataZone glossary, serving as a standardized definition for a specific business concept or data element. Each term can include rich metadata such as detailed definitions, synonyms, related terms, and usage examples. Glossary terms can be linked directly to data assets, providing business context to technical data elements. This linking capability helps users understand the business meaning of data fields and ensures consistent interpretation across different systems and teams. Terms can also have relationships with other terms, creating a semantic network that reflects the complexity of business concepts.</p> <p>Prerequisites:</p> <ul> <li> <p>Domain must exist. </p> </li> <li> <p>Glossary must exist.</p> </li> <li> <p>The term name must be unique within the glossary.</p> </li> <li> <p>Ensure term does not conflict with existing terms in hierarchy.</p> </li> </ul>

    Args:
        domain_identifier: <p>The ID of the Amazon DataZone domain in which this business glossary term is created.</p>
        glossary_identifier: <p>The ID of the business glossary in which this term is created.</p>
        name: <p>The name of this business glossary term.</p>
        status: <p>The status of this business glossary term.</p>
        short_description: <p>The short description of this business glossary term.</p>
        long_description: <p>The long description of this business glossary term.</p>
        term_relations: <p>The term relations of this business glossary term.</p>
        client_token: <p>A unique, case-sensitive identifier that is provided to ensure the idempotency of the request.</p>

    Raises:
        capo_datazone.errors.access_denied_exception.AccessDeniedException: <p>You do not have sufficient access to perform this action.</p>
        capo_datazone.errors.throttling_exception.ThrottlingException: <p>The request was denied due to request throttling.</p>
        capo_datazone.errors.unauthorized_exception.UnauthorizedException: <p>You do not have permission to perform this action.</p>
        capo_datazone.errors.conflict_exception.ConflictException: <p>There is a conflict while performing this action.</p>
        capo_datazone.errors.internal_server_exception.InternalServerException: <p>The request has failed because of an unknown error, exception or failure.</p>
        capo_datazone.errors.resource_not_found_exception.ResourceNotFoundException: <p>The specified resource cannot be found.</p>
        capo_datazone.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>The request has exceeded the specified service quota.</p>
        capo_datazone.errors.validation_exception.ValidationException: <p>The input fails to satisfy the constraints specified by the Amazon Web Services service.</p>
        capo_datazone.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_datazone.types.create_glossary_term_input.CreateGlossaryTermInput]",
    ) -> AsyncOperationResponse[
        "capo_datazone.types.create_glossary_term_output.CreateGlossaryTermOutput"
    ]:
        import capo_datazone._operations.data_zone.create_glossary_term

        (
            output,
            http_response,
        ) = await capo_datazone._operations.data_zone.create_glossary_term.async_create_glossary_term(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    def _redact_input(
        input_: "capo_datazone.types.create_glossary_term_input.CreateGlossaryTermInput",
    ) -> dict[str, Any]:
        import capo_datazone.types.create_glossary_term_input

        return capo_datazone.types.create_glossary_term_input.redact_sensitive(
            input_
        )

    def _redact_output(
        output: "capo_datazone.types.create_glossary_term_output.CreateGlossaryTermOutput",
    ) -> dict[str, Any]:
        import capo_datazone.types.create_glossary_term_output

        return capo_datazone.types.create_glossary_term_output.redact_sensitive(
            output
        )

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging(
            "CreateGlossaryTerm",
            redact_input=_redact_input,
            redact_output=_redact_output,
        ),
    )
    input_: capo_datazone.types.create_glossary_term_input.CreateGlossaryTermInput = {
        "domain_identifier": domain_identifier,
        "glossary_identifier": glossary_identifier,
        "name": name,
    }
    if status is not None:
        input_["status"] = status
    if short_description is not None:
        input_["short_description"] = short_description
    if long_description is not None:
        input_["long_description"] = long_description
    if term_relations is not None:
        input_["term_relations"] = term_relations
    if client_token is None:
        client_token = str(uuid.uuid4())
    input_["client_token"] = client_token

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output