maps4fs 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

maps4fs/generator/dtm/scotland.py

@@ -1,118 +0,0 @@
-"""This module contains provider of Scotland data."""
-
-import os
-
-import requests
-
-from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
-
-
-class ScotlandProviderSettings(DTMProviderSettings):
-    """Settings for the Scotland provider."""
-
-    dataset: dict | str = {
-        "scotland-gov/lidar/phase-1/dtm": "LiDAR for Scotland Phase I DTM",
-        "scotland-gov/lidar/phase-2/dtm": "LiDAR for Scotland Phase II DTM",
-        "scotland-gov/lidar/phase-3/dtm": "LiDAR for Scotland Phase III DTM",
-        "scotland-gov/lidar/phase-4/dtm": "LiDAR for Scotland Phase IV DTM",
-        "scotland-gov/lidar/phase-5/dtm": "LiDAR for Scotland Phase V DTM",
-        "scotland-gov/lidar/phase-6/dtm": "LiDAR for Scotland Phase VI DTM",
-        "scotland-gov/lidar/hes/hes-2010/dtm": (
-            "HES LiDAR Data Stirling City and surrounding area (2010) DTM"
-        ),
-        "scotland-gov/lidar/hes/hes-2010s10/dtm": (
-            "LiDAR for Historic Environment Scotland Scottish Ten Project (2010) DTM"
-        ),
-        "scotland-gov/lidar/hes/hes-2016-2017/dtm": (
-            "LiDAR for Historic Environment Scotland Projects (2016-2017 sub project 4) DTM"
-        ),
-        "scotland-gov/lidar/hes/hes-2016/dtm": (
-            "LiDAR for Historic Environment Scotland Projects (2016) DTM"
-        ),
-        "scotland-gov/lidar/hes/hes-2017/dtm": (
-            "LiDAR for Historic Environment Scotland Projects (2017) DTM"
-        ),
-        "scotland-gov/lidar/hes/hes-2017sp3/dtm": (
-            "LiDAR for Historic Environment Scotland Project (2017 Sub Project 3) DTM"
-        ),
-        "scotland-gov/lidar/hes/hes-luing/dtm": (
-            "LiDAR for Historic Environment Scotland Projects Isle of Luing DTM"
-        ),
-        "scotland-gov/lidar/outerheb-2019/dtm/25cm": "LiDAR for Outer Hebrides 2019 - 25cm DTM",
-        "scotland-gov/lidar/outerheb-2019/dtm/50cm": "LiDAR for Outer Hebrides 2019 - 50cm DTM",
-    }
-
-
-class ScotlandProvider(DTMProvider):
-    """Provider of Scotland."""
-
-    _code = "scotland"
-    _name = "Scotland LiDAR"
-    _region = "UK"
-    _icon = "🏴󠁧󠁢󠁳󠁣󠁴󠁿"
-    _resolution = "variable"
-    _settings = ScotlandProviderSettings
-    _author = "[kbrandwijk](https://github.com/kbrandwijk)"
-    _is_community = True
-    _instructions = (
-        "Coverage for Scotland is very limited. "
-        "Make sure to check the [coverage map](https://remotesensingdata.gov.scot/data#/map)."
-    )
-    _extents = [
-        (60.2151105070992756, 54.5525982243521881, -1.1045617513147328, -6.7070796770431951)
-    ]
-
-    _url = "https://srsp-catalog.jncc.gov.uk/search/product"
-
-    def download_tiles(self):
-        download_urls = self.get_download_urls()
-        all_tif_files = self.download_tif_files(download_urls, self.shared_tiff_path)
-        return all_tif_files
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.shared_tiff_path = os.path.join(self._tile_directory, "shared")
-        os.makedirs(self.shared_tiff_path, exist_ok=True)
-
-    def get_download_urls(self) -> list[str]:
-        """Get download URLs of the GeoTIFF files from the USGS API.
-
-        Returns:
-            list: List of download URLs.
-        """
-        urls = []
-        try:
-            # Make the GET request
-            (north, south, east, west) = self.get_bbox()
-            response = requests.post(  # pylint: disable=W3101
-                self.url,  # type: ignore
-                json={
-                    "collections": (
-                        [self.user_settings.dataset] if self.user_settings else []  # type: ignore
-                    ),
-                    "footprint": (
-                        f"POLYGON(({west} {south}, {west} {north}, "
-                        f"{east} {north}, {east} {south}, {west} {south}))"
-                    ),
-                    "offset": 0,
-                    "limit": 100,
-                    "spatialop": "intersects",
-                },
-                timeout=60,
-            )
-            self.logger.debug("Getting file locations from JNCC...")
-
-            # Check if the request was successful (HTTP status code 200)
-            if response.status_code == 200:
-                # Parse the JSON response
-                json_data = response.json()
-                items = json_data["result"]
-                for item in items:
-                    urls.append(item["data"]["product"]["http"]["url"])
-                # self.download_tif_files(urls)
-            else:
-                self.logger.error("Failed to get data. HTTP Status Code: %s", response.status_code)
-        except requests.exceptions.RequestException as e:
-            self.logger.error("Failed to get data. Error: %s", e)
-        self.logger.debug("Received %s urls", len(urls))
-        return urls

maps4fs/generator/dtm/spain.py

@@ -1,33 +0,0 @@
-"""This module contains provider of Spain data."""
-
-from maps4fs.generator.dtm.base.wcs import WCSProvider
-from maps4fs.generator.dtm.dtm import DTMProvider
-
-
-class SpainProvider(WCSProvider, DTMProvider):
-    """Provider of Spain data."""
-
-    _code = "spain"
-    _name = "Spain"
-    _region = "ES"
-    _icon = "🇪🇸"
-    _resolution = 5
-    _author = "[kbrandwijk](https://github.com/kbrandwijk)"
-    _is_community = True
-    _is_base = False
-    _extents = [
-        (43.9299999999999997, 27.6299999999999990, 4.9400000000000004, -18.2100000000000009)
-    ]
-
-    _url = "https://servicios.idee.es/wcs-inspire/mdt"
-    _wcs_version = "2.0.1"
-    _source_crs = "EPSG:25830"
-    _tile_size = 1000
-
-    def get_wcs_parameters(self, tile: tuple[float, float, float, float]) -> dict:
-        return {
-            "identifier": ["Elevacion25830_5"],
-            "subsets": [("y", str(tile[0]), str(tile[2])), ("x", str(tile[1]), str(tile[3]))],
-            "format": "GEOTIFFINT16",
-            "timeout": 600,
-        }

maps4fs/generator/dtm/srtm.py

@@ -1,122 +0,0 @@
-"""This module contains provider of Shuttle Radar Topography Mission (SRTM) 30m data."""
-
-# Author: https://github.com/iwatkot
-
-import gzip
-import math
-import os
-import shutil
-
-import requests
-
-from maps4fs.generator.dtm.dtm import DTMProvider
-
-
-class SRTM30Provider(DTMProvider):
-    """Provider of Shuttle Radar Topography Mission (SRTM) 30m data."""
-
-    _code = "srtm30"
-    _name = "SRTM 30 m"
-    _region = "Global"
-    _icon = "🌎"
-    _resolution = 30.0
-
-    _url = "https://elevation-tiles-prod.s3.amazonaws.com/skadi/{latitude_band}/{tile_name}.hgt.gz"
-
-    _author = "[iwatkot](https://github.com/iwatkot)"
-
-    # _instructions = "ℹ️ Recommended settings:  \nDEM Settings -> Blur Radius: **35**"
-
-    _default_settings = {"DEMSettings": {"blur_radius": 35}}
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.hgt_directory = os.path.join(self._tile_directory, "hgt")
-        self.gz_directory = os.path.join(self._tile_directory, "gz")
-        os.makedirs(self.hgt_directory, exist_ok=True)
-        os.makedirs(self.gz_directory, exist_ok=True)
-
-    def download_tiles(self):
-        """Download SRTM tiles."""
-        north, south, east, west = self.get_bbox()
-
-        tiles = []
-        # Look at each corner of the bbox in case the bbox spans across multiple tiles
-        for pair in [(north, east), (south, west), (south, east), (north, west)]:
-            tile_parameters = self.get_tile_parameters(*pair)
-            tile_name = tile_parameters["tile_name"]
-            decompressed_tile_path = os.path.join(self.hgt_directory, f"{tile_name}.hgt")
-
-            if not os.path.isfile(decompressed_tile_path):
-                compressed_tile_path = os.path.join(self.gz_directory, f"{tile_name}.hgt.gz")
-                if not self.get_or_download_tile(compressed_tile_path, **tile_parameters):
-                    raise FileNotFoundError(f"Tile {tile_name} not found.")
-
-                with gzip.open(compressed_tile_path, "rb") as f_in:
-                    with open(decompressed_tile_path, "wb") as f_out:
-                        shutil.copyfileobj(f_in, f_out)
-            tiles.append(decompressed_tile_path)
-
-        return list(set(tiles))
-
-    # region provider specific helpers
-    def download_tile(self, output_path: str, **kwargs) -> bool:
-        """Download a tile from the provider.
-
-        Arguments:
-            output_path (str): Path to save the downloaded tile.
-
-        Returns:
-            bool: True if the tile was downloaded successfully, False otherwise.
-        """
-        url = self.formatted_url(**kwargs)
-        response = requests.get(url, stream=True, timeout=10)
-        if response.status_code == 200:
-            with open(output_path, "wb") as file:
-                for chunk in response.iter_content(chunk_size=1024):
-                    file.write(chunk)
-            return True
-        return False
-
-    def get_or_download_tile(self, output_path: str, **kwargs) -> str | None:
-        """Get or download a tile from the provider.
-
-        Arguments:
-            output_path (str): Path to save the downloaded tile.
-
-        Returns:
-            str: Path to the downloaded tile or None if the tile not exists and was
-                not downloaded.
-        """
-        if not os.path.exists(output_path):
-            if not self.download_tile(output_path, **kwargs):
-                return None
-        return output_path
-
-    def get_tile_parameters(self, *args) -> dict[str, str]:
-        """Returns latitude band and tile name for SRTM tile from coordinates.
-
-        Arguments:
-            lat (float): Latitude.
-            lon (float): Longitude.
-
-        Returns:
-            dict: Tile parameters.
-        """
-        lat, lon = args
-
-        tile_latitude = math.floor(lat)
-        tile_longitude = math.floor(lon)
-
-        latitude_band = f"N{abs(tile_latitude):02d}" if lat >= 0 else f"S{abs(tile_latitude):02d}"
-        if lon < 0:
-            tile_name = f"{latitude_band}W{abs(tile_longitude):03d}"
-        else:
-            tile_name = f"{latitude_band}E{abs(tile_longitude):03d}"
-
-        self.logger.debug(
-            "Detected tile name: %s for coordinates: lat %s, lon %s.", tile_name, lat, lon
-        )
-        return {"latitude_band": latitude_band, "tile_name": tile_name}
-
-    # endregion

maps4fs/generator/dtm/switzerland.py

@@ -1,104 +0,0 @@
-"""This module contains provider of Switzerland data."""
-
-import json
-import os
-
-import requests
-
-from maps4fs.generator.dtm import utils
-from maps4fs.generator.dtm.dtm import DTMProvider, DTMProviderSettings
-
-
-class SwitzerlandProviderSettings(DTMProviderSettings):
-    """Settings for the Switzerland provider."""
-
-    resolution: tuple | str = ("0.5", "2.0")
-
-
-class SwitzerlandProvider(DTMProvider):
-    """Provider of Switzerland."""
-
-    _code = "switzerland"
-    _name = "Switzerland"
-    _region = "CH"
-    _icon = "🇨🇭"
-    _resolution = "0.5-2"
-    _settings = SwitzerlandProviderSettings
-    _author = "[kbrandwijk](https://github.com/kbrandwijk)"
-    _is_community = True
-
-    _extents = [(47.8308275417, 45.7769477403, 10.4427014502, 6.02260949059)]
-
-    _url = (
-        "https://ogd.swisstopo.admin.ch/services/swiseld/"
-        "services/assets/ch.swisstopo.swissalti3d/search"
-    )
-
-    def download_tiles(self):
-        download_urls = self.get_download_urls()
-        all_tif_files = self.download_tif_files(download_urls, self.shared_tiff_path)
-        return all_tif_files
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.shared_tiff_path = os.path.join(self._tile_directory, "shared")
-        os.makedirs(self.shared_tiff_path, exist_ok=True)
-
-    def get_download_urls(self) -> list[str]:
-        """Get download URLs of the GeoTIFF files from the USGS API.
-
-        Returns:
-            list: List of download URLs.
-        """
-        urls = []
-        try:
-            bbox = self.get_bbox()
-            north, south, east, west = utils.transform_bbox(bbox, "EPSG:2056")
-
-            params = {
-                "format": "image/tiff; application=geotiff; profile=cloud-optimized",
-                "resolution": self.user_settings.resolution,  # type: ignore
-                "srid": 2056,
-                "state": "current",
-            }
-
-            data = {
-                "geometry": json.dumps(
-                    {
-                        "type": "Polygon",
-                        "crs": {"type": "name", "properties": {"name": "EPSG:2056"}},
-                        "coordinates": [
-                            [
-                                [north, east],
-                                [south, east],
-                                [south, west],
-                                [north, west],
-                                [north, east],
-                            ]
-                        ],
-                    }
-                )
-            }
-
-            response = requests.post(  # pylint: disable=W3101
-                self.url,  # type: ignore
-                params=params,
-                data=data,
-                headers={"Content-Type": "application/x-www-form-urlencoded"},
-                timeout=60,
-            )
-            self.logger.debug("Getting file locations...")
-
-            # Check if the request was successful (HTTP status code 200)
-            if response.status_code == 200:
-                # Parse the JSON response
-                json_data = response.json()
-                items = json_data["items"]
-                for item in items:
-                    urls.append(item["ass_asset_href"])
-            else:
-                self.logger.error("Failed to get data. HTTP Status Code: %s", response.status_code)
-        except requests.exceptions.RequestException as e:
-            self.logger.error("Failed to get data. Error: %s", e)
-        self.logger.debug("Received %s urls", len(urls))
-        return urls

maps4fs/generator/dtm/thuringia.py

@@ -1,60 +0,0 @@
-"""This module contains provider of Thuringia data."""
-
-import os
-from maps4fs.generator.dtm import utils
-from maps4fs.generator.dtm.dtm import DTMProvider
-
-class ThuringiaProvider(DTMProvider):
-    """Provider of Thuringia data.
-    Data is provided by the Kompetenzzentrum Geodateninfrastruktur Thüringen (© GDI-Th) and available
-    at https://geoportal.thueringen.de/gdi-th/download-offene-geodaten/download-hoehendaten under BY 2.0 license.
-    """
-    _code = "thuringia"
-    _name = "Thüringen DGM1"
-    _region = "DE"
-    _icon = "🇩🇪󠁥󠁢󠁹󠁿"
-    _resolution = 1
-    _author = "[H4rdB4se](https://github.com/H4rdB4se)"
-    _is_community = True
-    _instructions = None
-    _extents = [(51.5997, 50.2070, 12.69674, 9.8548)]
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.tiff_path = os.path.join(self._tile_directory, "tiffs")
-        os.makedirs(self.tiff_path, exist_ok=True)
-
-    def download_tiles(self) -> list[str]:
-        bbox = self.get_bbox()
-        west, east, north, south = utils.transform_bbox(bbox, "EPSG:25832")
-        download_urls = self.get_download_urls(north, south, east, west)
-        all_tif_files = self.download_tif_files(download_urls, self.tiff_path)
-        return all_tif_files
-
-    @staticmethod
-    def get_first_n_digits(value: float, digits: int) -> int:
-        """Get the first n digits of a number."""
-        return int(str(value)[:digits])
-
-    def get_download_urls(self, north: float, south: float, east: float, west: float) -> list[str]:
-        """Calculate all possible tiles within the bounding box.
-
-        Args:
-            north (float): Northern boundary.
-            south (float): Southern boundary.
-            east (float): Eastern boundary.
-            west (float): Western boundary.
-
-        Returns:
-            list: List of tile names.
-        """
-        urls = []
-        lat = self.get_first_n_digits(south, 4)
-        while lat <= self.get_first_n_digits(north, 4):
-            lon = self.get_first_n_digits(west, 3)
-            while lon <= self.get_first_n_digits(east, 3):
-                tile_url = f"https://geoportal.geoportal-th.de/hoehendaten/DGM/dgm_2020-2025/dgm1_32_{lon}_{lat}_1_th_2020-2025.zip"
-                urls.append(tile_url)
-                lon += 1
-            lat += 1
-        return urls

maps4fs/generator/dtm/usgs_wcs.py

@@ -1,35 +0,0 @@
-"""This module contains provider of USGS data."""
-
-from maps4fs.generator.dtm.base.wcs import WCSProvider
-from maps4fs.generator.dtm.dtm import DTMProvider
-
-
-class USGSWCSProvider(WCSProvider, DTMProvider):
-    """Provider of USGS data."""
-
-    _code = "usgs_wcs"
-    _name = "USGS"
-    _region = "USA"
-    _icon = "🇺🇸"
-    _resolution = "1-90"
-    _author = "[kbrandwijk](https://github.com/kbrandwijk)"
-    _is_community = True
-    _instructions = None
-    _is_base = False
-    _extents = [(50.0, 17.0, -64.0, -162.0)]
-
-    _url = "https://elevation.nationalmap.gov/arcgis/services/3DEPElevation/ImageServer/WCSServer"
-    _wcs_version = "1.0.0"
-    _source_crs = "EPSG:3857"
-    _tile_size = 1000
-    _is_multipart = False
-
-    def get_wcs_parameters(self, tile):
-        return {
-            "identifier": "DEP3Elevation",
-            "bbox": (tile[1], tile[0], tile[3], tile[2]),
-            "crs": "EPSG:3857",
-            "width": 1000,
-            "height": 1000,
-            "format": "GeoTIFF",
-        }

maps4fs/generator/dtm/utils.py

@@ -1,61 +0,0 @@
-"""Utility functions for the DTM generator."""
-
-import numpy as np
-from pyproj import Transformer
-
-
-def tile_bbox(
-    bbox: tuple[float, float, float, float], tile_size: float
-) -> list[tuple[float, float, float, float]]:
-    """Tile the bounding box into smaller bounding boxes of a specified size.
-
-    Arguments:
-        bbox (tuple): Bounding box to tile (north, south, east, west).
-        tile_size (int): Size of the tiles in meters.
-
-    Returns:
-        list: List of smaller bounding boxes (north, south, east, west).
-    """
-    north, south, east, west = bbox
-    x_coords = np.arange(west, east, tile_size if east > west else -tile_size)
-    y_coords = np.arange(north, south, tile_size if south > north else -tile_size)
-    x_coords = np.append(x_coords, east).astype(x_coords.dtype)
-    y_coords = np.append(y_coords, south).astype(y_coords.dtype)
-
-    x_min, y_min = np.meshgrid(x_coords[:-1], y_coords[:-1], indexing="ij")
-    x_max, y_max = np.meshgrid(x_coords[1:], y_coords[1:], indexing="ij")
-
-    tiles = np.stack(
-        [x_min.ravel(), y_min.ravel(), x_max.ravel(), y_max.ravel()], axis=1, dtype=float
-    )
-
-    return [tuple(tile[i].item() for i in range(4)) for tile in tiles]
-
-
-def transform_bbox(
-    bbox: tuple[float, float, float, float], to_crs: str
-) -> tuple[float, float, float, float]:
-    """Transform the bounding box to a different coordinate reference system (CRS).
-
-    Arguments:
-        bbox (tuple): Bounding box to transform (north, south, east, west).
-        to_crs (str): Target CRS (e.g., EPSG:4326 for CRS:84).
-
-    Returns:
-        tuple: Transformed bounding box (north, south, east, west).
-    """
-    transformer = Transformer.from_crs("epsg:4326", to_crs)
-    north, south, east, west = bbox
-
-    # EPSG:4326 is lat, lon, so xx is lat and yy is lon
-    bottom_left_x, bottom_left_y = transformer.transform(xx=south, yy=west)
-    top_left_x, top_left_y = transformer.transform(xx=north, yy=west)
-    top_right_x, top_right_y = transformer.transform(xx=north, yy=east)
-    bottom_right_x, bottom_right_y = transformer.transform(xx=south, yy=east)
-
-    west = min(bottom_left_y, bottom_right_y)
-    east = max(top_left_y, top_right_y)
-    north = min(bottom_left_x, top_left_x)
-    south = max(bottom_right_x, top_right_x)
-
-    return north, south, east, west

maps4fs/generator/dtm/wales.py

@@ -1,123 +0,0 @@
-"""This module contains provider of Wales data."""
-
-import os
-from math import floor, ceil
-
-import requests
-from pyproj import Transformer
-
-from maps4fs.generator.dtm.dtm import DTMProvider
-
-
-class WalesProvider(DTMProvider):
-    """Provider of Wales data."""
-
-    _code = "wales"
-    _name = "Wales 1M"
-    _region = "UK"
-    _icon = "🏴󠁧󠁢󠁷󠁬󠁳󠁿󠁧󠁢󠁷󠁬󠁳󠁿"
-    _resolution = 1
-    _author = "[garnshared](https://github.com/garnshared)"
-    _is_community = True
-    _instructions = None
-    _is_base = False
-    _extents = [(55.87708724246775, 49.85060473351981, 2.0842821419111135, -7.104775741839742)]
-
-    _url = "https://datamap.gov.wales/geoserver/ows"  # pylint: disable=line-too-long
-    _wms_version = "1.1.1"
-    _source_crs = "EPSG:27700"
-    _size = 1000
-
-    def download_tiles(self):
-        download_urls = self.get_download_urls()
-        all_tif_files = self.download_tif_files(download_urls, self.shared_tiff_path)
-        return all_tif_files
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.shared_tiff_path = os.path.join(self._tile_directory, "shared")
-        os.makedirs(self.shared_tiff_path, exist_ok=True)
-
-    def get_download_urls(self) -> list[str]:
-        """Get download URLs of the GeoTIFF files from the tile catalogue.
-
-        Returns:
-            list: List of download URLs.
-        """
-        urls = []
-
-        transformer = Transformer.from_crs("EPSG:4326", "EPSG:27700", always_xy=True)
-
-
-        # Make the GET request
-        north, south, east, west = self.get_bbox()
-
-        # Transform the coordinates
-        west_transformed, south_transformed = transformer.transform(west, south)
-        east_transformed, north_transformed = transformer.transform(east, north)
-
-        # Helper function to snap coordinate to nearest 1000 grid
-        def snap_to_grid(value, func):
-            return int(func(value * 0.001) * 1000)
-
-        # Snap bounding box coordinates to a 1000-unit grid
-        x_min = snap_to_grid(west_transformed, floor)
-        y_min = snap_to_grid(south_transformed, floor)
-        x_max = snap_to_grid(east_transformed, ceil)
-        y_max = snap_to_grid(north_transformed, ceil)
-
-        # Calculate the number of tiles in x and y directions
-        x_tiles = abs(x_max - x_min) // 1000
-        y_tiles = abs(y_max - y_min) // 1000
-
-
-        for x_tile in range(x_tiles):
-            for y_tile in range(y_tiles):
-                b_west = x_min + 1000 * (x_tile + 1) - 855
-                b_south = y_min + 1000 * (y_tile + 1) - 855
-                b_east = b_west + 145
-                b_north = b_south + 145
-
-                try:
-                    params = {
-                        "service": "WMS",
-                        "version": self._wms_version,
-                        "request": "GetFeatureInfo",
-                        "exceptions": "application/json",
-                        "layers": "geonode:welsh_government_lidar_tile_catalogue_2020_2023",
-                        "query_layers": "geonode:welsh_government_lidar_tile_catalogue_2020_2023",
-                        "styles": "",
-                        "x": 51,
-                        "y": 51,
-                        "height": 101,
-                        "width": 101,
-                        "srs": self._source_crs,
-                        "bbox": f"{b_west},{b_south},{b_east},{b_north}",
-                        "feature_count": 10,
-                        "info_format": "application/json",
-                        "ENV": "mapstore_language:en"
-                    }
-
-                    response = requests.get(# pylint: disable=W3101
-                        self.url,  # type: ignore
-                        params=params,  # type: ignore
-                        timeout=60
-                    )
-
-                    self.logger.debug("Getting file locations from Welsh Government WMS GetFeatureInfo...")
-
-                    # Check if the request was successful (HTTP status code 200)
-                    if response.status_code == 200:
-                        json_data = response.json()
-                        features = json_data.get("features", [])
-                        for feature in features:
-                            dtm_link = feature.get("properties", {}).get("dtm_link")
-                            if dtm_link:
-                                urls.append("https://"+dtm_link)
-                    else:
-                        self.logger.error("Failed to get data. HTTP Status Code: %s", response.status_code)
-                except Exception as e:
-                    self.logger.error("Failed to get data. Error: %s", e)
-
-        self.logger.debug("Received %s urls", len(urls))
-        return urls