How to use the routingpy.utils function in routingpy

def _parse_geometry(route_geometry):
            if geometry_format in (None, 'polyline'):
                geometry = [
                    list(reversed(coord))
                    for coord in utils.decode_polyline5(route_geometry, is3d=False)
                ]
            elif geometry_format == 'polyline6':
                geometry = [
                    list(reversed(coord))
                    for coord in utils.decode_polyline6(route_geometry, is3d=False)
                ]
            elif geometry_format == 'geojson':
                geometry = route_geometry['coordinates']
            else:
                raise ValueError(
                    "OSRM: parameter geometries needs one of ['polyline', 'polyline6', 'geojson"
                )
            return geometry

return Direction()

        units_factor = 1
        if units == 'mi':
            units_factor = 0.621371 * 1000
        elif units == 'km':
            units_factor = 1000

        if format == 'geojson':
            geometry = response['features'][0]['geometry']['coordinates']
            duration = int(response['features'][0]['properties']['summary']['duration'])
            distance = int(response['features'][0]['properties']['summary']['distance'])
        elif format == 'json':
            geometry = [
                list(reversed(coord))
                for coord in utils.decode_polyline5(response['routes'][0]['geometry'])
            ]
            duration = int(response['routes'][0]['summary']['duration'])
            distance = int(response['routes'][0]['summary']['distance'] * units_factor)

        return Direction(geometry=geometry, duration=duration, distance=distance, raw=response)

list(reversed(coord))
                    for coord in utils.decode_polyline5(route['points'], elevation)
                ]
                routes.append(
                    Direction(
                        geometry=geometry,
                        duration=int(route['time'] / 1000),
                        distance=int(route['distance']),
                        raw=route
                    )
                )
            return Directions(routes, response)
        else:
            geometry = [
                list(reversed(coord))
                for coord in utils.decode_polyline5(response['paths'][0]['points'], elevation)
            ]
            return Direction(
                geometry=geometry,
                duration=int(response['paths'][0]['time'] / 1000),
                distance=int(response['paths'][0]['distance']),
                raw=response
            )

def _parse_geometry(route_geometry):
            if geometry_format in (None, 'polyline'):
                geometry = utils.decode_polyline5(route_geometry, is3d=False)
            elif geometry_format == 'polyline6':
                geometry = utils.decode_polyline6(route_geometry, is3d=False)
            elif geometry_format == 'geojson':
                geometry = route_geometry['coordinates']
            else:
                raise ValueError(
                    "OSRM: parameter geometries needs one of ['polyline', 'polyline6', 'geojson"
                )
            return geometry

def _parse_geometry(route_geometry):
            if geometry_format in (None, 'polyline'):
                geometry = [
                    list(reversed(coord))
                    for coord in utils.decode_polyline5(route_geometry, is3d=False)
                ]
            elif geometry_format == 'polyline6':
                geometry = [
                    list(reversed(coord))
                    for coord in utils.decode_polyline6(route_geometry, is3d=False)
                ]
            elif geometry_format == 'geojson':
                geometry = route_geometry['coordinates']
            else:
                raise ValueError(
                    "OSRM: parameter geometries needs one of ['polyline', 'polyline6', 'geojson"
                )
            return geometry

def _parse_direction_json(response, units):
        if response is None:  # pragma: no cover
            return Direction()

        geometry, duration, distance = [], 0, 0
        for leg in response['trip']['legs']:
            geometry.extend([list(reversed(coord)) for coord in utils.decode_polyline6(leg['shape'])])
            duration += leg['summary']['time']

            factor = 0.621371 if units == 'mi' else 1
            distance += int(leg['summary']['length'] * 1000 * factor)

        return Direction(geometry=geometry, duration=int(duration), distance=int(distance), raw=response)

def _parse_directions_json(response, algorithm, elevation):
        if response is None:  # pragma: no cover
            if algorithm == 'alternative_route':
                return Directions()
            else:
                return Direction()

        if algorithm == 'alternative_route':
            routes = []
            for route in response['paths']:
                geometry = [
                    list(reversed(coord))
                    for coord in utils.decode_polyline5(route['points'], elevation)
                ]
                routes.append(
                    Direction(
                        geometry=geometry,
                        duration=int(route['time'] / 1000),
                        distance=int(route['distance']),
                        raw=route
                    )
                )
            return Directions(routes, response)
        else:
            geometry = [
                list(reversed(coord))
                for coord in utils.decode_polyline5(response['paths'][0]['points'], elevation)
            ]
            return Direction(

Direction(
                        geometry=geometry, duration=int(duration), distance=int(distance), raw=route
                    )
                )
            return Directions(routes, response)
        else:
            geometry = []
            duration, distance = 0, 0
            for leg in response['routes'][0]['legs']:
                duration = int(leg['duration']['value'])
                distance = int(leg['distance']['value'])
                for step in leg['steps']:
                    geometry.extend(
                        [
                            list(reversed(coords))
                            for coords in utils.decode_polyline5(step['polyline']['points'])
                        ]
                    )
            return Direction(geometry=geometry, duration=duration, distance=distance, raw=response)

else:
                return Direction()

        if alternatives:
            routes = []
            for route in response['routes']:
                geometry = []
                duration, distance = 0, 0
                for leg in route['legs']:
                    duration += leg['duration']['value']
                    distance += leg['distance']['value']
                    for step in leg['steps']:
                        geometry.extend(
                            [
                                list(reversed(coords))
                                for coords in utils.decode_polyline5(step['polyline']['points'])
                            ]
                        )
                routes.append(
                    Direction(
                        geometry=geometry, duration=int(duration), distance=int(distance), raw=route
                    )
                )
            return Directions(routes, response)
        else:
            geometry = []
            duration, distance = 0, 0
            for leg in response['routes'][0]['legs']:
                duration = int(leg['duration']['value'])
                distance = int(leg['distance']['value'])
                for step in leg['steps']:
                    geometry.extend(