create_threat_model async ¶

async def create_threat_model(
    self,
    title: str,
    agent_space_id: str,
    service_role: "capo_securityagent.types.service_role.ServiceRole",
    *,
    config_overrides: Optional[AsyncSecurityAgentClientConfig] = None,
    description: Optional[str] = None,
    assets: Optional["capo_securityagent.types.assets.Assets"] = None,
    scope_docs: Optional[
        "capo_securityagent.types.document_list.DocumentList"
    ] = None,
    log_config: Optional[
        "capo_securityagent.types.cloud_watch_log.CloudWatchLog"
    ] = None,
    report_destination: Optional[
        "capo_securityagent.types.report_destination.ReportDestination"
    ] = None,
) -> "capo_securityagent.types.create_threat_model_output.CreateThreatModelOutput":
    """<p>Creates a new threat model configuration in an agent space. A threat model defines the parameters for automated threat analysis.</p>

    Args:
        title: <p>The title of the threat model.</p>
        agent_space_id: <p>The unique identifier of the agent space to create the threat model in.</p>
        description: <p>A description of the application or system being threat modeled.</p>
        assets: <p>The assets to include in the threat model.</p>
        scope_docs: <p>The scoped documents for the agent to focus on during threat modeling.</p>
        service_role: <p>The IAM service role to use for the threat model.</p>
        log_config: <p>The CloudWatch Logs configuration for the threat model.</p>
        report_destination: <p>The destination for publishing scan reports to an integrated document provider.</p>

    Raises:
        capo_securityagent.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_securityagent.types.create_threat_model_input.CreateThreatModelInput]",
    ) -> AsyncOperationResponse[
        "capo_securityagent.types.create_threat_model_output.CreateThreatModelOutput"
    ]:
        import capo_securityagent._operations.security_agent.create_threat_model

        (
            output,
            http_response,
        ) = await capo_securityagent._operations.security_agent.create_threat_model.async_create_threat_model(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    def _redact_input(
        input_: "capo_securityagent.types.create_threat_model_input.CreateThreatModelInput",
    ) -> dict[str, Any]:
        import capo_securityagent.types.create_threat_model_input

        return capo_securityagent.types.create_threat_model_input.redact_sensitive(
            input_
        )

    def _redact_output(
        output: "capo_securityagent.types.create_threat_model_output.CreateThreatModelOutput",
    ) -> dict[str, Any]:
        import capo_securityagent.types.create_threat_model_output

        return capo_securityagent.types.create_threat_model_output.redact_sensitive(
            output
        )

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging(
            "CreateThreatModel",
            redact_input=_redact_input,
            redact_output=_redact_output,
        ),
    )
    input_: capo_securityagent.types.create_threat_model_input.CreateThreatModelInput = {
        "title": title,
        "agent_space_id": agent_space_id,
        "service_role": service_role,
    }
    if description is not None:
        input_["description"] = description
    if assets is not None:
        input_["assets"] = assets
    if scope_docs is not None:
        input_["scope_docs"] = scope_docs
    if log_config is not None:
        input_["log_config"] = log_config
    if report_destination is not None:
        input_["report_destination"] = report_destination

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