<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def wrapper(vertices_resources, vertices_applications, nets, net_keys, machine, constraints=[], reserve_monitor=True, align_sdram=True, place=default_place, place_kwargs={}, allocate=default_allocate, allocate_kwargs={}, route=default_route, route_kwargs={}, core_resource=Cores, sdram_resource=SDRAM):
 """Wrapper for core place-and-route tasks for the common case. At a high level this function essentially takes a set of vertices and nets and produces placements, memory allocations, routing tables and application loading information. .. warning:: This function is deprecated. New users should use :py:func:`.place_and_route_wrapper` along with :py:meth:`rig.machine_control.MachineController.get_system_info` in place of this function. The new wrapper automatically reserves cores and SDRAM already in use in the target machine, improving on the behaviour of this wrapper which blindly reserves certain ranges of resources presuming only core 0 (the monitor processor) is not idle. Parameters A dictionary from vertex to the required resources for that vertex. This dictionary must include an entry for every vertex in the application. Resource requirements are specified by a dictionary `{resource: `quantity` is a non-negative integer representing the quantity of that resource required. A dictionary from vertices to the application binary to load onto cores associated with that vertex. Applications are given as a string containing the file name of the binary to load. A list (in no particular order) defining the nets connecting vertices. A dictionary from nets to (key, mask) tuples to be used in SpiNNaker routing tables for routes implementing this net. The key and mask should be given as 32-bit integers. machine : :py:class:`rig.place_and_route.Machine` A data structure which defines the resources available in the target SpiNNaker machine. A list of constraints on placement, allocation and routing. Available constraints are provided in the :py:mod:`rig.place_and_route.constraints` module. reserve_monitor : bool (Default: True) **Optional.** If True, reserve core zero since it will be used as the monitor processor using a :py:class:`rig.place_and_route.constraints.ReserveResourceConstraint`. align_sdram : bool (Default: True) **Optional.** If True, SDRAM allocations will be aligned to 4-byte addresses. Specifically, the supplied constraints will be augmented with an `AlignResourceConstraint(sdram_resource, 4)`. place : function (Default: :py:func:`rig.place_and_route.place`) **Optional.** Placement algorithm to use. place_kwargs : dict (Default: {}) **Optional.** Algorithm-specific arguments for the placer. allocate : function (Default: :py:func:`rig.place_and_route.allocate`) **Optional.** Allocation algorithm to use. allocate_kwargs : dict (Default: {}) **Optional.** Algorithm-specific arguments for the allocator. route : function (Default: :py:func:`rig.place_and_route.route`) **Optional.** Routing algorithm to use. route_kwargs : dict (Default: {}) **Optional.** Algorithm-specific arguments for the router. core_resource : resource (Default: :py:data:`~rig.place_and_route.Cores`) **Optional.** The resource identifier used for cores. sdram_resource : resource (Default: :py:data:`~rig.place_and_route.SDRAM`) **Optional.** The resource identifier used for SDRAM. Returns ------- A dictionary from vertices to the chip coordinate produced by placement. A dictionary from vertices to the resources allocated to it. Resource allocations are dictionaries from resources to a :py:class:`slice` defining the range of the given resource type allocated to the vertex. These :py:class:`slice` objects have `start` <= `end` and `step` set to None. A dictionary from application to the set of cores it should be loaded onto. The set of cores is given as a dictionary from chip to sets of core numbers. routing_tables : {(x, y):
 \ [:py:class:`~rig.routing_table.RoutingTableEntry`, \ The generated routing tables. Provided as a dictionary from chip to a list of routing table entries. """

    warnings.warn("rig.place_and_route.wrapper is deprecated "
                  "use rig.place_and_route.place_and_route_wrapper instead in "
                  "new applications.",
                  DeprecationWarning)
    constraints = constraints[:]

    # Augment constraints with (historically) commonly used constraints
    if reserve_monitor:
        constraints.append(
            ReserveResourceConstraint(core_resource, slice(0, 1)))
    if align_sdram:
        constraints.append(AlignResourceConstraint(sdram_resource, 4))

    # Place/Allocate/Route
    placements = place(vertices_resources, nets, machine, constraints,
                       **place_kwargs)
    allocations = allocate(vertices_resources, nets, machine, constraints,
                           placements, **allocate_kwargs)
    routes = route(vertices_resources, nets, machine, constraints, placements,
                   allocations, core_resource, **route_kwargs)

    # Build data-structures ready to feed to the machine loading functions
    application_map = build_application_map(vertices_applications, placements,
                                            allocations, core_resource)

    # Build data-structures ready to feed to the machine loading functions
    from rig.place_and_route.utils import build_routing_tables
    routing_tables = build_routing_tables(routes, net_keys)

    return placements, allocations, application_map, routing_tables