def extract_bower_zipfile(self, zip_file, dest, expected_version=None):
        bower_json = None
        root = None
        deps_installed = []
        for info in zip_file.infolist():
            if PurePath(info.filename).name == "bower.json":
                with zip_file.open(info) as f:
                    bower_json = json.load(f)
                    root = str(PurePath(info.filename).parent)
                break
        version = bower_json["version"]
        if expected_version is not None:
            expected_version = Bower.clean_semver(expected_version)
            if not semver.match(version, expected_version):
                click.secho("error: versions do not match ({} =/= {})".format(
                    version, expected_version))
                raise InvalidPackageError
        if "dependencies" in bower_json:
            for package, version in bower_json["dependencies"].items():
                url = Bower.get_package_url(package)
                deps_installed.extend(self.get_bower_package(
                    url, dest=dest, version=version))
        ignore_patterns = [GitIgnorePattern(ig) for ig in bower_json["ignore"]]
        path_spec = PathSpec(ignore_patterns)
        namelist = [path for path in zip_file.namelist()
                    if PurePath(path).parts[0] == root]
        ignored = list(path_spec.match_files(namelist))
        for path in namelist:
            dest_path = PurePath(
                bower_json["name"],
                *PurePath(path).parts[1:])

            if path in ignored:
                continue

            for path in ignored:
                for parent in PurePath(path):
                    if parent in ignored:
                        continue

            if path.endswith("/"):
                if list(path_spec.match_files([str(dest_path)])):
                    ignored.append(PurePath(path))
                elif not (dest / dest_path).is_dir():
                    (dest / dest_path).mkdir(parents=True)
            else:
                target_path = dest / dest_path.parent / dest_path.name
                source = zip_file.open(path)
                target = target_path.open("wb")
                with source, target:
                    shutil.copyfileobj(source, target)
        deps_installed.append((bower_json["name"], bower_json["version"]))
        return deps_installed
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