Diff Coverage

            try:
                candidate = anchor_mesh[mesh_dim_names]
            except (KeyError, ValueError, RuntimeError, NotImplementedError):
                continue
            candidate_attrs = (
                candidate.device_type == mesh.device_type,
                candidate.mesh_shape == mesh.mesh_shape,
                candidate.rank_list == mesh.rank_list,
                candidate._flatten_rank_map == flatten_rank_map,  # pylint: disable=protected-access

                candidate.mesh_shape == mesh.mesh_shape,
                candidate.rank_list == mesh.rank_list,
                candidate._flatten_rank_map == flatten_rank_map,  # pylint: disable=protected-access
            )
            if all(candidate_attrs):
                return candidate
        return None

    @staticmethod

        mesh = init_device_mesh(device_type="npu", mesh_shape=(platform.get_world_size(),))
    if mesh is not None:
        device = _get_device_from_mesh(mesh)
    else:
        compat_mesh = None
        for param in params:
            dtensor_mesh = get_dtensor_managed_mesh(param)
            if dtensor_mesh is not None:
                compat_mesh = dtensor_mesh
                break
        if compat_mesh is None:
            raise ValueError("fully_shard could not resolve a DTensor mesh for compatibility mode.")
        device = _get_device_from_mesh(compat_mesh)

    for cell_name in return_local_tensor_list:
        register_cell = cell_dict.get(cell_name)
        if register_cell is None:
            raise KeyError(f"Cannot find cell {cell_name!r} in sharded cell.")
        register_cell.register_forward_hook(hook_func)


def _shard_callable(func: Callable, sharding_plan: Dict):