snap_to_roads async ¶

async def snap_to_roads(
    self,
    trace_points: "capo_geo_routes.types.road_snap_trace_point_list.RoadSnapTracePointList",
    *,
    config_overrides: Optional[AsyncGeoRoutesClientConfig] = None,
    key: Optional["capo_geo_routes.types.api_key.ApiKey"] = None,
    snapped_geometry_format: Optional[
        "capo_geo_routes.types.geometry_format.GeometryFormat"
    ] = None,
    snap_radius: Optional[
        "capo_geo_routes.types.distance_meters.DistanceMeters"
    ] = None,
    travel_mode: Optional[
        "capo_geo_routes.types.road_snap_travel_mode.RoadSnapTravelMode"
    ] = None,
    travel_mode_options: Optional[
        "capo_geo_routes.types.road_snap_travel_mode_options.RoadSnapTravelModeOptions"
    ] = None,
) -> "capo_geo_routes.types.snap_to_roads_response.SnapToRoadsResponse":
    """<p> <code>SnapToRoads</code> matches GPS trace to roads most likely traveled on.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/location/latest/developerguide/snap-to-roads.html">Snap to Roads</a> in the <i>Amazon Location Service Developer Guide</i>.</p>

    Args:
        key: <p>Optional: The API key to be used for authorization. Either an API key or valid SigV4 signature must be provided when making a request. </p>
        snapped_geometry_format: <p>Chooses what the returned SnappedGeometry format should be.</p> <p>Default value: <code>FlexiblePolyline</code> </p>
        snap_radius: <p>The radius around the provided tracepoint that is considered for snapping.</p> <p> <b>Unit</b>: <code>meters</code> </p> <p>Default value: <code>300</code> </p>
        trace_points: <p>List of trace points to be snapped onto the road network.</p>
        travel_mode: <p>Specifies the mode of transport when calculating a route. Used in estimating the speed of travel and road compatibility.</p> <p>Default value: <code>Car</code> </p>
        travel_mode_options: <p>Travel mode related options for the provided travel mode.</p>

    Raises:
        capo_geo_routes.errors.access_denied_exception.AccessDeniedException: <p>You don't have sufficient access to perform this action.</p>
        capo_geo_routes.errors.internal_server_exception.InternalServerException: <p>The request processing has failed because of an unknown error, exception or failure.</p>
        capo_geo_routes.errors.throttling_exception.ThrottlingException: <p>The request was denied due to request throttling.</p>
        capo_geo_routes.errors.validation_exception.ValidationException: <p>The input fails to satisfy the constraints specified by an AWS service.</p>
        capo_geo_routes.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_geo_routes.types.snap_to_roads_request.SnapToRoadsRequest]",
    ) -> AsyncOperationResponse[
        "capo_geo_routes.types.snap_to_roads_response.SnapToRoadsResponse"
    ]:
        import capo_geo_routes._operations.routes_service.snap_to_roads

        (
            output,
            http_response,
        ) = await capo_geo_routes._operations.routes_service.snap_to_roads.async_snap_to_roads(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    def _redact_input(
        input_: "capo_geo_routes.types.snap_to_roads_request.SnapToRoadsRequest",
    ) -> dict[str, Any]:
        import capo_geo_routes.types.snap_to_roads_request

        return capo_geo_routes.types.snap_to_roads_request.redact_sensitive(input_)

    def _redact_output(
        output: "capo_geo_routes.types.snap_to_roads_response.SnapToRoadsResponse",
    ) -> dict[str, Any]:
        import capo_geo_routes.types.snap_to_roads_response

        return capo_geo_routes.types.snap_to_roads_response.redact_sensitive(output)

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging(
            "SnapToRoads", redact_input=_redact_input, redact_output=_redact_output
        ),
    )
    input_: capo_geo_routes.types.snap_to_roads_request.SnapToRoadsRequest = {
        "trace_points": trace_points
    }
    if key is not None:
        input_["key"] = key
    if snapped_geometry_format is not None:
        input_["snapped_geometry_format"] = snapped_geometry_format
    if snap_radius is not None:
        input_["snap_radius"] = snap_radius
    if travel_mode is not None:
        input_["travel_mode"] = travel_mode
    if travel_mode_options is not None:
        input_["travel_mode_options"] = travel_mode_options

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