Python io.Downloader类代码示例

 def __init__(self,
              url_template=_NE_URL_TEMPLATE,
              target_path_template=None,
              pre_downloaded_path_template='',
              ):
     # adds some NE defaults to the __init__ of a Downloader
     Downloader.__init__(self, url_template,
                         target_path_template,
                         pre_downloaded_path_template)

 def __init__(self,
              target_path_template,
              pre_downloaded_path_template='',
              ):
     # adds some SRTM3 defaults to the __init__ of a Downloader
     # namely, the URl is determined on the fly using the
     # ``SRTM3Downloader._SRTM3_LOOKUP_URL`` dictionary
     Downloader.__init__(self, None,
                         target_path_template,
                         pre_downloaded_path_template)

 def __init__(self, target_path_template, pre_downloaded_path_template=""):
     # adds some SRTM defaults to the __init__ of a Downloader
     # namely, the URL is determined on the fly using the
     # ``SRTMDownloader._SRTM_LOOKUP_MASK`` array
     Downloader.__init__(self, None, target_path_template, pre_downloaded_path_template)
     warnings.warn(
         "SRTM requires an account set up and log in to access."
         "use of this class is likely to fail with"
         " HTTP 401 errors."
     )

def natural_earth(resolution="110m", category="physical", name="coastline"):
    """
    Returns the path to the requested natural earth shapefile,
    downloading and unziping if necessary.

    To identify valid components for this function, either browse
    NaturalEarthData.com, or if you know what you are looking for, go to
    https://github.com/nvkelso/natural-earth-vector/tree/master/zips to
    see the actual files which will be downloaded.

    .. note::

        Some of the Natural Earth shapefiles have special features which are
        described in the name. For example, the 110m resolution
        "admin_0_countries" data also has a sibling shapefile called
        "admin_0_countries_lakes" which excludes lakes in the country
        outlines. For details of what is available refer to the Natural Earth
        website, and look at the "download" link target to identify
        appropriate names.

    """
    # get hold of the Downloader (typically a NEShpDownloader instance)
    # which we can then simply call its path method to get the appropriate
    # shapefile (it will download if necessary)
    ne_downloader = Downloader.from_config(("shapefiles", "natural_earth", resolution, category, name))
    format_dict = {"config": config, "category": category, "name": name, "resolution": resolution}
    return ne_downloader.path(format_dict)

def gshhs(scale="c", level=1):
    """
    Returns the path to the requested GSHHS shapefile,
    downloading and unziping if necessary.

    """
    # Get hold of the Downloader (typically a GSHHSShpDownloader instance)
    # and call its path method to get the appropriate shapefile (it will
    # download it if necessary).
    gshhs_downloader = Downloader.from_config(("shapefiles", "gshhs", scale, level))
    format_dict = {"config": config, "scale": scale, "level": level}
    return gshhs_downloader.path(format_dict)

def gshhs(scale='c', level=1):
    """
    Returns the path to the requested GSHHS shapefile,
    downloading and unziping if necessary.

    """
    # Get hold of the Downloader (typically a GSHHSShpDownloader instance)
    # and call its path method to get the appropriate shapefile (it will
    # download it if necessary).
    gshhs_downloader = Downloader.from_config(('shapefiles', 'gshhs',
                                               scale, level))
    format_dict = {'config': config, 'scale': scale, 'level': level}
    return gshhs_downloader.path(format_dict)

def natural_earth(resolution='110m', category='physical', name='coastline'):
    """
    Returns the path to the requested natural earth shapefile,
    downloading and unziping if necessary.

    """
    # get hold of the Downloader (typically a NEShpDownloader instance)
    # which we can then simply call its path method to get the appropriate
    # shapefile (it will download if necessary)
    ne_downloader = Downloader.from_config(('shapefiles', 'natural_earth',
                                            resolution, category, name))
    format_dict = {'config': config, 'category': category,
                   'name': name, 'resolution': resolution}
    return ne_downloader.path(format_dict)

def SRTM3_retrieve(lon, lat):
    """
    Return the path of a .hgt file for the given SRTM location.

    If no such .hgt file exists (because it is over the ocean)
    None will be returned.

    """
    x = '%s%03d' % ('E' if lon > 0 else 'W', abs(int(lon)))
    y = '%s%02d' % ('N' if lat > 0 else 'S', abs(int(lat)))

    srtm_downloader = Downloader.from_config(('SRTM', 'SRTM3'))
    params = {'config': config, 'x': x, 'y': y}
    if srtm_downloader.url(params) is None:
        return None
    else:
        return srtm_downloader.path({'config': config, 'x': x, 'y': y})

    def srtm_fname(self, lon, lat):
        """
        Return the filename for the given lon/lat SRTM tile (downloading if
        necessary), or None if no such tile exists (i.e. the tile would be
        entirely over water, or out of latitude range).

        """
        if int(lon) != lon or int(lat) != lat:
            raise ValueError('Integer longitude/latitude values required.')

        x = '%s%03d' % ('E' if lon >= 0 else 'W', abs(int(lon)))
        y = '%s%02d' % ('N' if lat >= 0 else 'S', abs(int(lat)))

        srtm_downloader = Downloader.from_config(('SRTM', 'SRTM3'))
        params = {'config': config, 'x': x, 'y': y}

        # If the URL doesn't exist then we are over sea/north/south of the
        # limits of the SRTM data and we return None.
        if srtm_downloader.url(params) is None:
            return None
        else:
            return self.downloader.path(params)

    def srtm_fname(self, lon, lat):
        """
        Return the filename for the given lon/lat SRTM tile (downloading if
        necessary), or None if no such tile exists (i.e. the tile would be
        entirely over water, or out of latitude range).

        """
        if int(lon) != lon or int(lat) != lat:
            raise ValueError("Integer longitude/latitude values required.")

        x = "%s%03d" % ("E" if lon >= 0 else "W", abs(int(lon)))
        y = "%s%02d" % ("N" if lat >= 0 else "S", abs(int(lat)))

        srtm_downloader = Downloader.from_config(("SRTM", "SRTM" + str(self._resolution)))
        params = {"config": config, "resolution": self._resolution, "x": x, "y": y}

        # If the URL doesn't exist then we are over sea/north/south of the
        # limits of the SRTM data and we return None.
        if srtm_downloader.url(params) is None:
            return None
        else:
            return self.downloader.path(params)

def SRTM3_retrieve(lon, lat):
    x = '%s%03d' % ('E' if lon > 0 else 'W', abs(int(lon)))
    y = '%s%02d' % ('N' if lat > 0 else 'S', abs(int(lat)))

    srtm_downloader = Downloader.from_config(('SRTM', 'SRTM3'))
    return srtm_downloader.path({'config': config, 'x': x, 'y': y})