create_remote_access_session async ¶

async def create_remote_access_session(
    self,
    project_arn: "capo_device_farm.types.amazon_resource_name.AmazonResourceName",
    device_arn: "capo_device_farm.types.amazon_resource_name.AmazonResourceName",
    *,
    config_overrides: Optional[AsyncDeviceFarmClientConfig] = None,
    app_arn: Optional[
        "capo_device_farm.types.amazon_resource_name.AmazonResourceName"
    ] = None,
    instance_arn: Optional[
        "capo_device_farm.types.amazon_resource_name.AmazonResourceName"
    ] = None,
    name: Optional["capo_device_farm.types.name.Name"] = None,
    configuration: Optional[
        "capo_device_farm.types.create_remote_access_session_configuration.CreateRemoteAccessSessionConfiguration"
    ] = None,
    interaction_mode: Optional[
        "capo_device_farm.types.interaction_mode.InteractionMode"
    ] = None,
    skip_app_resign: Optional["capo_device_farm.types.boolean.Boolean"] = None,
) -> "capo_device_farm.types.create_remote_access_session_result.CreateRemoteAccessSessionResult":
    """<p>Specifies and starts a remote access session.</p>

    Args:
        project_arn: <p>The Amazon Resource Name (ARN) of the project for which you want to create a remote access session.</p>
        device_arn: <p>The ARN of the device for which you want to create a remote access session.</p>
        app_arn: <p>The Amazon Resource Name (ARN) of the app to create the remote access session.</p>
        instance_arn: <p>The Amazon Resource Name (ARN) of the device instance for which you want to create a remote access session.</p>
        name: <p>The name of the remote access session to create.</p>
        configuration: <p>The configuration information for the remote access session request.</p>
        interaction_mode: <p>The interaction mode of the remote access session. Changing the interactive mode of remote access sessions is no longer available.</p>
        skip_app_resign: <p>When set to <code>true</code>, for private devices, Device Farm does not sign your app again. For public devices, Device Farm always signs your apps again.</p> <p>For more information on how Device Farm modifies your uploads during tests, see <a href="http://aws.amazon.com/device-farm/faqs/">Do you modify my app?</a> </p>

    Raises:
        capo_device_farm.errors.argument_exception.ArgumentException: <p>An invalid argument was specified.</p>
        capo_device_farm.errors.limit_exceeded_exception.LimitExceededException: <p>A limit was exceeded.</p>
        capo_device_farm.errors.not_found_exception.NotFoundException: <p>The specified entity was not found.</p>
        capo_device_farm.errors.service_account_exception.ServiceAccountException: <p>There was a problem with the service account.</p>
        capo_device_farm.errors.UnknownServiceError: The service returned an error code this client does not model.

    Examples:
        To create a remote access session
        The following example creates a remote access session named MySession.

        >>> await client.create_remote_access_session(project_arn='arn:aws:devicefarm:us-west-2:123456789101:project:EXAMPLE-GUID-123-456', device_arn='arn:aws:devicefarm:us-west-2::device:123EXAMPLE', name='MySession', configuration={'billingMethod': 'METERED'})
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_device_farm.types.create_remote_access_session_request.CreateRemoteAccessSessionRequest]",
    ) -> AsyncOperationResponse[
        "capo_device_farm.types.create_remote_access_session_result.CreateRemoteAccessSessionResult"
    ]:
        import capo_device_farm._operations.device_farm_20150623.create_remote_access_session

        (
            output,
            http_response,
        ) = await capo_device_farm._operations.device_farm_20150623.create_remote_access_session.async_create_remote_access_session(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    def _redact_output(
        output: "capo_device_farm.types.create_remote_access_session_result.CreateRemoteAccessSessionResult",
    ) -> dict[str, Any]:
        import capo_device_farm.types.create_remote_access_session_result

        return capo_device_farm.types.create_remote_access_session_result.redact_sensitive(
            output
        )

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging("CreateRemoteAccessSession", redact_output=_redact_output),
    )
    input_: capo_device_farm.types.create_remote_access_session_request.CreateRemoteAccessSessionRequest = {
        "project_arn": project_arn,
        "device_arn": device_arn,
    }
    if app_arn is not None:
        input_["app_arn"] = app_arn
    if instance_arn is not None:
        input_["instance_arn"] = instance_arn
    if name is not None:
        input_["name"] = name
    if configuration is not None:
        input_["configuration"] = configuration
    if interaction_mode is not None:
        input_["interaction_mode"] = interaction_mode
    if skip_app_resign is not None:
        input_["skip_app_resign"] = skip_app_resign

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