def download_file(url, dest=None, chunk_size=1024, replace="ask",
                  label="Downloading {dest_basename} ({size:.2f}MB)",
                  expected_extension=None):
    """Download a file from a given URL and display progress.

    :param dest: If the destination exists and is a directory, the filename
        will be guessed from the Content-Disposition header. If the destination
        is an existing file, the user will either be prompted to overwrite, or
        the file will be replaced (depending on the value of **replace**). If
        the destination does not exist, it will be used as the filename.
    :param int chunk_size: bytes read in at a time.
    :param replace: If `False`, an existing destination file will not be
        overwritten.
    :param label: a string which is formatted and displayed as the progress bar
        label. Variables provided include *dest_basename*, *dest*, and *size*.
    :param expected_extension: if set, the filename will be sanitized to ensure
        it has the given extension. The extension should not start with a dot
        (`.`).
    """
    dest = Path(dest or url.split("/")[-1])
    response = get(url, stream=True)
    if (dest.exists()
            and dest.is_dir()
            and "Content-Disposition" in response.headers):
        content_disposition = rfc6266.parse_requests_response(response)
        if expected_extension is not None:
            filename = content_disposition.filename_sanitized(
                expected_extension)
        filename = secure_filename(filename)
        dest = dest / filename
    if dest.exists() and not dest.is_dir():
        if (replace is False
                or replace == "ask"
                and not click.confirm("Replace {}?".format(dest))):
            return str(dest)
    size = int(response.headers.get("content-length", 0))
    label = label.format(dest=dest, dest_basename=dest.name,
                         size=size/1024.0/1024)
    with click.open_file(str(dest), "wb") as f:
        content_iter = response.iter_content(chunk_size=chunk_size)
        with click.progressbar(content_iter, length=size/1024,
                               label=label) as bar:
            for chunk in bar:
                if chunk:
                    f.write(chunk)
                    f.flush()
    return str(dest)
def _read_metadata_from_example_file(netcdf_file_name, include_soundings):
    """Reads metadata from file with input examples.

    :param netcdf_file_name: Path to input file.
    :param include_soundings: Boolean flag.  If True and file contains
        soundings, this method will return keys "sounding_field_names" and
        "sounding_heights_m_agl".  Otherwise, will not return said keys.

    :return: example_dict: Dictionary with the following keys (explained in doc
        to `write_example_file`).
    example_dict['full_id_strings']
    example_dict['storm_times_unix_sec']
    example_dict['radar_field_names']
    example_dict['radar_heights_m_agl']
    example_dict['rotated_grids']
    example_dict['rotated_grid_spacing_metres']
    example_dict['target_names']
    example_dict['sounding_field_names']
    example_dict['sounding_heights_m_agl']

    :return: netcdf_dataset: Instance of `netCDF4.Dataset`, which can be used to
        keep reading file.
    """

    netcdf_dataset = netCDF4.Dataset(netcdf_file_name)
    include_soundings = (
        include_soundings and
        SOUNDING_FIELDS_KEY in netcdf_dataset.variables
    )

    example_dict = {
        ROTATED_GRIDS_KEY: bool(getattr(netcdf_dataset, ROTATED_GRIDS_KEY)),
        TARGET_NAMES_KEY: [
            str(s) for s in
            netCDF4.chartostring(netcdf_dataset.variables[TARGET_NAMES_KEY][:])
        ],
        FULL_IDS_KEY: [
            str(s) for s in
            netCDF4.chartostring(netcdf_dataset.variables[FULL_IDS_KEY][:])
        ],
        STORM_TIMES_KEY: numpy.array(
            netcdf_dataset.variables[STORM_TIMES_KEY][:], dtype=int
        ),
        RADAR_FIELDS_KEY: [
            str(s) for s in
            netCDF4.chartostring(netcdf_dataset.variables[RADAR_FIELDS_KEY][:])
        ],
        RADAR_HEIGHTS_KEY: numpy.array(
            netcdf_dataset.variables[RADAR_HEIGHTS_KEY][:], dtype=int
        )
    }

    # TODO(thunderhoser): This is a HACK to deal with bad files.
    example_dict[TARGET_NAMES_KEY] = [
        n for n in example_dict[TARGET_NAMES_KEY] if n != ''
    ]

    if example_dict[ROTATED_GRIDS_KEY]:
        example_dict[ROTATED_GRID_SPACING_KEY] = getattr(
            netcdf_dataset, ROTATED_GRID_SPACING_KEY)
    else:
        example_dict[ROTATED_GRID_SPACING_KEY] = None

    if not include_soundings:
        return example_dict, netcdf_dataset

    example_dict.update({
        SOUNDING_FIELDS_KEY: [
            str(s) for s in netCDF4.chartostring(
                netcdf_dataset.variables[SOUNDING_FIELDS_KEY][:])
        ],
        SOUNDING_HEIGHTS_KEY:
            numpy.array(netcdf_dataset.variables[SOUNDING_HEIGHTS_KEY][:],
                        dtype=int)
    })

    return example_dict, netcdf_dataset