update_flow_output async ¶

async def update_flow_output(
    self,
    flow_arn: "capo_mediaconnect.types.flow_arn.FlowArn",
    output_arn: str,
    *,
    config_overrides: Optional[AsyncMediaConnectClientConfig] = None,
    cidr_allow_list: Optional[
        "capo_mediaconnect.types.__list_of_string.__listOfString"
    ] = None,
    description: Optional[str] = None,
    destination: Optional[str] = None,
    encryption: Optional[
        "capo_mediaconnect.types.update_encryption.UpdateEncryption"
    ] = None,
    max_latency: Optional[int] = None,
    media_stream_output_configurations: Optional[
        "capo_mediaconnect.types.__list_of_media_stream_output_configuration_request.__listOfMediaStreamOutputConfigurationRequest"
    ] = None,
    min_latency: Optional[int] = None,
    port: Optional[int] = None,
    protocol: Optional["capo_mediaconnect.types.protocol.Protocol"] = None,
    remote_id: Optional[str] = None,
    sender_control_port: Optional[int] = None,
    sender_ip_address: Optional[str] = None,
    smoothing_latency: Optional[int] = None,
    stream_id: Optional[str] = None,
    vpc_interface_attachment: Optional[
        "capo_mediaconnect.types.vpc_interface_attachment.VpcInterfaceAttachment"
    ] = None,
    output_status: Optional[
        "capo_mediaconnect.types.output_status.OutputStatus"
    ] = None,
    ndi_program_name: Optional[str] = None,
    ndi_speed_hq_quality: Optional[int] = None,
    router_integration_state: Optional[
        "capo_mediaconnect.types.state.State"
    ] = None,
    router_integration_transit_encryption: Optional[
        "capo_mediaconnect.types.flow_transit_encryption.FlowTransitEncryption"
    ] = None,
    ndi_output_timecode_source: Optional[
        "capo_mediaconnect.types.ndi_output_timecode_source.NdiOutputTimecodeSource"
    ] = None,
    ndi_audio_reference_level: Optional[
        "capo_mediaconnect.types.ndi_audio_reference_level.NdiAudioReferenceLevel"
    ] = None,
) -> "capo_mediaconnect.types.update_flow_output_response.UpdateFlowOutputResponse":
    """<p> Updates an existing flow output.</p>

    Args:
        cidr_allow_list: <p> The range of IP addresses that should be allowed to initiate output requests to this flow. These IP addresses should be in the form of a Classless Inter-Domain Routing (CIDR) block; for example, 10.0.0.0/16.</p>
        description: <p> A description of the output. This description appears only on the MediaConnect console and will not be seen by the end user.</p>
        destination: <p> The IP address where you want to send the output.</p>
        encryption: <p> The type of key used for the encryption. If no <code>keyType</code> is provided, the service will use the default setting (static-key). Allowable encryption types: static-key.</p>
        flow_arn: <p> The Amazon Resource Name (ARN) of the flow that is associated with the output that you want to update.</p>
        max_latency: <p> The maximum latency in milliseconds. This parameter applies only to RIST-based and Zixi-based streams.</p>
        media_stream_output_configurations: <p> The media streams that are associated with the output, and the parameters for those associations.</p>
        min_latency: <p> The minimum latency in milliseconds for SRT-based streams. In streams that use the SRT protocol, this value that you set on your MediaConnect source or output represents the minimal potential latency of that connection. The latency of the stream is set to the highest number between the sender’s minimum latency and the receiver’s minimum latency.</p>
        output_arn: <p> The ARN of the output that you want to update.</p>
        port: <p> The port to use when content is distributed to this output.</p>
        protocol: <p> The protocol to use for the output.</p> <note> <p>Elemental MediaConnect no longer supports the Fujitsu QoS protocol. This reference is maintained for legacy purposes only.</p> </note>
        remote_id: <p> The remote ID for the Zixi-pull stream.</p>
        sender_control_port: <p> The port that the flow uses to send outbound requests to initiate connection with the sender.</p>
        sender_ip_address: <p> The IP address that the flow communicates with to initiate connection with the sender.</p>
        smoothing_latency: <p> The smoothing latency in milliseconds for RIST, RTP, and RTP-FEC streams.</p>
        stream_id: <p> The stream ID that you want to use for this transport. This parameter applies only to Zixi and SRT caller-based streams.</p>
        vpc_interface_attachment: <p> The name of the VPC interface attachment to use for this output.</p>
        output_status: <p> An indication of whether the output should transmit data or not. If you don't specify the <code>outputStatus</code> field in your request, MediaConnect leaves the value unchanged.</p>
        ndi_program_name: <p> A suffix for the name of the NDI® sender that the flow creates. If a custom name isn't specified, MediaConnect uses the output name. </p>
        ndi_speed_hq_quality: <p>A quality setting for the NDI Speed HQ encoder. </p>
        router_integration_state: <p>Indicates whether to enable or disable router integration for this flow output.</p>
        ndi_output_timecode_source: <p>Controls how MediaConnect generates timecodes for NDI output frames. If you don't specify this field, MediaConnect leaves the value unchanged.</p> <ul> <li> <p> <code>EMBEDDED_TIMECODE</code> - Preserves timecodes from the input transport stream. The timecodes must be embedded in the video stream as SEI timing messages. If no embedded timecode is detected, MediaConnect uses the UTC system time instead.</p> </li> <li> <p> <code>UTC_SYSTEM_TIME</code> - Generates timecodes based on the system clock time when each frame is sent.</p> </li> </ul>
        ndi_audio_reference_level: <p>The audio reference level of the NDI receiver, in decibels relative to full scale (dBFS). Common values are <code>-20</code> (NDI and SMPTE) and <code>-18</code> (EBU). If you don't specify this field, MediaConnect leaves the value unchanged.</p>

    Raises:
        capo_mediaconnect.errors.bad_request_exception.BadRequestException: <p>This exception is thrown if the request contains a semantic error. The precise meaning depends on the API, and is documented in the error message. </p>
        capo_mediaconnect.errors.forbidden_exception.ForbiddenException: <p>You do not have sufficient access to perform this action. </p>
        capo_mediaconnect.errors.internal_server_error_exception.InternalServerErrorException: <p>The server encountered an internal error and is unable to complete the request. </p>
        capo_mediaconnect.errors.not_found_exception.NotFoundException: <p>One or more of the resources in the request does not exist in the system. </p>
        capo_mediaconnect.errors.service_unavailable_exception.ServiceUnavailableException: <p>The service is currently unavailable or busy. </p>
        capo_mediaconnect.errors.too_many_requests_exception.TooManyRequestsException: <p>The request was denied due to request throttling. </p>
        capo_mediaconnect.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_mediaconnect.types.update_flow_output_request.UpdateFlowOutputRequest]",
    ) -> AsyncOperationResponse[
        "capo_mediaconnect.types.update_flow_output_response.UpdateFlowOutputResponse"
    ]:
        import capo_mediaconnect._operations.media_connect.update_flow_output

        (
            output,
            http_response,
        ) = await capo_mediaconnect._operations.media_connect.update_flow_output.async_update_flow_output(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("UpdateFlowOutput")
    )
    input_: capo_mediaconnect.types.update_flow_output_request.UpdateFlowOutputRequest = {
        "flow_arn": flow_arn,
        "output_arn": output_arn,
    }
    if cidr_allow_list is not None:
        input_["cidr_allow_list"] = cidr_allow_list
    if description is not None:
        input_["description"] = description
    if destination is not None:
        input_["destination"] = destination
    if encryption is not None:
        input_["encryption"] = encryption
    if max_latency is not None:
        input_["max_latency"] = max_latency
    if media_stream_output_configurations is not None:
        input_["media_stream_output_configurations"] = (
            media_stream_output_configurations
        )
    if min_latency is not None:
        input_["min_latency"] = min_latency
    if port is not None:
        input_["port"] = port
    if protocol is not None:
        input_["protocol"] = protocol
    if remote_id is not None:
        input_["remote_id"] = remote_id
    if sender_control_port is not None:
        input_["sender_control_port"] = sender_control_port
    if sender_ip_address is not None:
        input_["sender_ip_address"] = sender_ip_address
    if smoothing_latency is not None:
        input_["smoothing_latency"] = smoothing_latency
    if stream_id is not None:
        input_["stream_id"] = stream_id
    if vpc_interface_attachment is not None:
        input_["vpc_interface_attachment"] = vpc_interface_attachment
    if output_status is not None:
        input_["output_status"] = output_status
    if ndi_program_name is not None:
        input_["ndi_program_name"] = ndi_program_name
    if ndi_speed_hq_quality is not None:
        input_["ndi_speed_hq_quality"] = ndi_speed_hq_quality
    if router_integration_state is not None:
        input_["router_integration_state"] = router_integration_state
    if router_integration_transit_encryption is not None:
        input_["router_integration_transit_encryption"] = (
            router_integration_transit_encryption
        )
    if ndi_output_timecode_source is not None:
        input_["ndi_output_timecode_source"] = ndi_output_timecode_source
    if ndi_audio_reference_level is not None:
        input_["ndi_audio_reference_level"] = ndi_audio_reference_level

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