<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def place_and_route_wrapper(vertices_resources, vertices_applications, nets, net_keys, system_info, constraints=[], place=default_place, place_kwargs={}, allocate=default_allocate, allocate_kwargs={}, route=default_route, route_kwargs={}, minimise_tables_methods=(remove_default_entries, ordered_covering), core_resource=Cores, sdram_resource=SDRAM, sram_resource=SRAM):
 """Wrapper for core place-and-route tasks for the common case. This function takes a set of vertices and nets and produces placements, allocations, minimised routing tables and application loading information. .. note:: This function replaces the deprecated :py:func:`.wrapper` function and makes use of the additional information provided by the :py:class:`~rig.machine_control.machine_controller.SystemInfo` object to infer the constraints required by most applications such as reserving non-idle cores such as the monitor processor. 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. system_info : \ :py:class:`~rig.machine_control.machine_controller.SystemInfo` A data structure which defines the resources available in the target SpiNNaker machine, typically returned by :py:meth:`rig.machine_control.MachineController.get_system_info`. This information will be used internally to build a :py:class:`~rig.place_and_route.Machine` and set of :py:mod:`rig.place_and_route.constraints` which describe the SpiNNaker machine used and ensure placement, allocation and routing only use working and unused chips, cores, memory and links. If greater control over these datastructures is required this wrapper may not be appropriate. **Optional.** A list of additional constraints on placement, allocation and routing. Available constraints are provided in the :py:mod:`rig.place_and_route.constraints` module. These constraints will be added to those derrived from the ``system_info`` argument which restrict placement and allocation to only idle cores. 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. **Optional.** An iterable of routing table minimisation algorithms to use when routing tables outgrow the space available. Each method is tried in the order presented and the first to meet the required target length for a given chip is used. Consequently less computationally costly algorithms should be nearer the start of the list. The default methods will try to remove default routes (:py:meth:`rig.routing_table.remove_default_routes.minimise`) and then fall back on the ordered covering algorithm (:py:meth:`rig.routing_table.ordered_covering.minimise`). 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. sram_resource : resource (Default: :py:data:`~rig.place_and_route.SRAM`) **Optional.** The resource identifier used for SRAM (System RAM). 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. """

    # Infer place-and-route data-structures from SystemInfo
    machine = build_machine(system_info,
                            core_resource=core_resource,
                            sdram_resource=sdram_resource,
                            sram_resource=sram_resource)
    base_constraints = build_core_constraints(system_info, core_resource)
    constraints = base_constraints + constraints

    # 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 routing tables from the generated routes
    routing_tables = routing_tree_to_tables(routes, net_keys)

    # Minimise the routing tables, if required
    target_lengths = build_routing_table_target_lengths(system_info)
    routing_tables = minimise_tables(routing_tables,
                                     target_lengths,
                                     minimise_tables_methods)

    return placements, allocations, application_map, routing_tables