giga-spatial 0.6.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

gigaspatial/generators/zonal/geometry.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, Union, Literal
 from shapely.geometry import Polygon, MultiPolygon
 
 import geopandas as gpd
@@ -6,7 +6,6 @@ import pandas as pd
 import logging
 
 from gigaspatial.core.io.data_store import DataStore
-from gigaspatial.config import config as global_config
 from gigaspatial.processing.geo import (
     add_area_in_meters,
     get_centroids,
@@ -14,6 +13,7 @@ from gigaspatial.processing.geo import (
 from gigaspatial.handlers.ghsl import GHSLDataHandler
 from gigaspatial.handlers.google_open_buildings import GoogleOpenBuildingsHandler
 from gigaspatial.handlers.microsoft_global_buildings import MSBuildingsHandler
+from gigaspatial.handlers.worldpop import WPPopulationHandler
 from gigaspatial.generators.zonal.base import (
     ZonalViewGenerator,
     ZonalViewGeneratorConfig,
@@ -136,9 +136,9 @@ class GeometryBasedZonalViewGenerator(ZonalViewGenerator[T]):
             List[T]: A list of zone identifiers in the order they appear in the
                 underlying GeoDataFrame.
         """
-        return self._zone_gdf[self.zone_id_column].tolist()
+        return self._zone_gdf.zone_id.tolist()
 
-    def to_geodataframe(self) -> gpd.GeoDataFrame:
+    def get_zone_geodataframe(self) -> gpd.GeoDataFrame:
         """Convert zones to a GeoDataFrame with standardized column names.
 
         Returns:
@@ -156,24 +156,23 @@ class GeometryBasedZonalViewGenerator(ZonalViewGenerator[T]):
         year=2020,
         resolution=100,
         stat: str = "sum",
-        name_prefix: str = "built_surface_m2_",
+        output_column: str = "built_surface_m2",
         **kwargs,
-    ) -> gpd.GeoDataFrame:
+    ) -> pd.DataFrame:
         """Map GHSL Built-up Surface data to zones.
 
         Convenience method for mapping Global Human Settlement Layer Built-up Surface
         data using appropriate default parameters for built surface analysis.
 
         Args:
-            ghsl_data_config (GHSLDataConfig): Configuration for GHSL Built-up Surface data.
-                Defaults to GHS_BUILT_S product for 2020 at 100m resolution.
+            year: The year of the data (default: 2020)
+            resolution: The resolution in meters (default: 100)
             stat (str): Statistic to calculate for built surface values within each zone.
                 Defaults to "sum" which gives total built surface area.
-            name_prefix (str): Prefix for the output column name. Defaults to "built_surface_m2_".
-
+            output_column (str): The output column name. Defaults to "built_surface_m2".
         Returns:
-            gpd.GeoDataFrame: Updated GeoDataFrame with zones and built surface metrics.
-                Adds a column named "{name_prefix}{stat}" containing the aggregated values.
+            pd.DataFrame: Updated view DataFrame and settlement classification.
+                Adds a column with `output_column` containing the aggregated values.
         """
         handler = GHSLDataHandler(
             product="GHS_BUILT_S",
@@ -184,32 +183,31 @@ class GeometryBasedZonalViewGenerator(ZonalViewGenerator[T]):
         )
 
         return self.map_ghsl(
-            handler=handler, stat=stat, name_prefix=name_prefix, **kwargs
+            handler=handler, stat=stat, output_column=output_column, **kwargs
         )
 
     def map_smod(
         self,
         year=2020,
-        resolution=100,
+        resolution=1000,
         stat: str = "median",
-        name_prefix: str = "smod_class_",
+        output_column: str = "smod_class",
         **kwargs,
-    ) -> gpd.GeoDataFrame:
+    ) -> pd.DataFrame:
         """Map GHSL Settlement Model data to zones.
 
         Convenience method for mapping Global Human Settlement Layer Settlement Model
         data using appropriate default parameters for settlement classification analysis.
 
         Args:
-            ghsl_data_config (GHSLDataConfig): Configuration for GHSL Settlement Model data.
-                Defaults to GHS_SMOD product for 2020 at 1000m resolution in Mollweide projection.
+            year: The year of the data (default: 2020)
+            resolution: The resolution in meters (default: 1000)
             stat (str): Statistic to calculate for settlement class values within each zone.
                 Defaults to "median" which gives the predominant settlement class.
-            name_prefix (str): Prefix for the output column name. Defaults to "smod_class_".
-
+            output_column (str): The output column name. Defaults to "smod_class".
         Returns:
-            gpd.GeoDataFrame: Updated GeoDataFrame with zones and settlement classification.
-                Adds a column named "{name_prefix}{stat}" containing the aggregated values.
+            pd.DataFrame: Updated view DataFrame and settlement classification.
+                Adds a column with `output_column` containing the aggregated values.
         """
         handler = GHSLDataHandler(
             product="GHS_SMOD",
@@ -221,32 +219,31 @@ class GeometryBasedZonalViewGenerator(ZonalViewGenerator[T]):
         )
 
         return self.map_ghsl(
-            handler=handler, stat=stat, name_prefix=name_prefix, **kwargs
+            handler=handler, stat=stat, output_column=output_column, **kwargs
         )
 
     def map_ghsl(
         self,
         handler: GHSLDataHandler,
         stat: str,
-        name_prefix: Optional[str] = None,
+        output_column: Optional[str] = None,
         **kwargs,
-    ) -> gpd.GeoDataFrame:
+    ) -> pd.DataFrame:
         """Map Global Human Settlement Layer data to zones.
 
         Loads and processes GHSL raster data for the intersecting tiles, then samples
         the raster values within each zone using the specified statistic.
 
         Args:
-            ghsl_data_config (GHSLDataConfig): Configuration specifying which GHSL
-                product, year, resolution, and coordinate system to use.
+            hander (GHSLDataHandler): Handler for the GHSL data.
             stat (str): Statistic to calculate for raster values within each zone.
                 Common options: "mean", "sum", "median", "min", "max".
-            name_prefix (str, optional): Prefix for the output column name.
+            output_column (str): The output column name.
                 If None, uses the GHSL product name in lowercase followed by underscore.
 
         Returns:
-            gpd.GeoDataFrame: Updated GeoDataFrame with zones and GHSL metrics.
-                Adds a column named "{name_prefix}{stat}" containing the sampled values.
+            pd.DataFrame: Updated DataFrame with GHSL metrics.
+                Adds a column named as `output_column` containing the sampled values.
 
         Note:
             The method automatically determines which GHSL tiles intersect with the zones
@@ -265,21 +262,21 @@ class GeometryBasedZonalViewGenerator(ZonalViewGenerator[T]):
         )
         sampled_values = self.map_rasters(tif_processors=tif_processors, stat=stat)
 
-        name_prefix = (
-            name_prefix if name_prefix else handler.config.product.lower() + "_"
+        column_name = (
+            output_column
+            if output_column
+            else f"{handler.config.product.lower()}_{stat}"
         )
-        column_name = f"{name_prefix}{stat}"
-        self._zone_gdf[column_name] = sampled_values
 
-        self.logger.info(f"Added {column_name} column")
+        self.add_variable_to_view(sampled_values, column_name)
 
-        return self._zone_gdf.copy()
+        return self.view
 
     def map_google_buildings(
         self,
         handler: Optional[GoogleOpenBuildingsHandler] = None,
         use_polygons: bool = False,
-    ) -> gpd.GeoDataFrame:
+    ) -> pd.DataFrame:
         """Map Google Open Buildings data to zones.
 
         Processes Google Open Buildings dataset to calculate building counts and total
@@ -295,7 +292,7 @@ class GeometryBasedZonalViewGenerator(ZonalViewGenerator[T]):
                 area values from attributes for faster processing. Defaults to False.
 
         Returns:
-            gpd.GeoDataFrame: Updated GeoDataFrame with zones and building metrics.
+            pd.DataFrame: Updated DataFrame with building metrics.
                 Adds columns:
                 - 'google_buildings_count': Number of buildings in each zone
                 - 'google_buildings_area_in_meters': Total building area in square meters
@@ -341,19 +338,20 @@ class GeometryBasedZonalViewGenerator(ZonalViewGenerator[T]):
             self.logger.info(
                 "Calculating building areas with area-weighted aggregation"
             )
-            area_result = self.map_polygons(buildings_gdf, area_weighted=True)
+            area_result = self.map_polygons(
+                buildings_gdf,
+                value_columns="area_in_meters",
+                aggregation="sum",
+                predicate="fractional",
+            )
 
             self.logger.info("Counting buildings using points data")
             count_result = self.map_points(points=buildings_df, predicate="within")
 
-        self._zone_gdf["google_buildings_count"] = self.zone_gdf.index.map(count_result)
-        self._zone_gdf["google_buildings_area_in_meters"] = self.zone_gdf.index.map(
-            area_result
-        )
-
-        self.logger.info(f"Added Google building data")
+        self.add_variable_to_view(count_result, "google_buildings_count")
+        self.add_variable_to_view(area_result, "google_buildings_area_in_meters")
 
-        return self._zone_gdf.copy()
+        return self.view
 
     def map_ms_buildings(
         self,
@@ -400,7 +398,9 @@ class GeometryBasedZonalViewGenerator(ZonalViewGenerator[T]):
             )
             return self._zone_gdf.copy()
 
-        buildings_gdf = add_area_in_meters(buildings_gdf)
+        buildings_gdf = add_area_in_meters(
+            buildings_gdf, area_column_name="area_in_meters"
+        )
 
         building_centroids = get_centroids(buildings_gdf)
 
@@ -421,7 +421,12 @@ class GeometryBasedZonalViewGenerator(ZonalViewGenerator[T]):
             self.logger.info(
                 "Calculating building areas with area-weighted aggregation"
             )
-            area_result = self.map_polygons(buildings_gdf, area_weighted=True)
+            area_result = self.map_polygons(
+                buildings_gdf,
+                value_columns="area_in_meters",
+                aggregation="sum",
+                predicate="fractional",
+            )
 
             self.logger.info("Counting Microsoft buildings per zone")
 
@@ -429,11 +434,104 @@ class GeometryBasedZonalViewGenerator(ZonalViewGenerator[T]):
                 points=building_centroids, predicate="within"
             )
 
-        self._zone_gdf["ms_buildings_count"] = self.zone_gdf.index.map(count_result)
-        self._zone_gdf["ms_buildings_area_in_meters"] = self.zone_gdf.index.map(
-            area_result
+        self.add_variable_to_view(count_result, "ms_buildings_count")
+        self.add_variable_to_view(area_result, "ms_buildings_area_in_meters")
+
+        return self.view
+
+    def map_ghsl_pop(
+        self,
+        resolution=100,
+        stat: str = "sum",
+        output_column: str = "ghsl_pop",
+        predicate: Literal["intersects", "fractional"] = "intersects",
+        **kwargs,
+    ):
+        handler = GHSLDataHandler(
+            product="GHS_POP",
+            resolution=resolution,
+            data_store=self.data_store,
+            **kwargs,
         )
 
-        self.logger.info(f"Added Microsoft building data")
+        if predicate == "fractional":
+            if resolution == 100:
+                self.logger.warning(
+                    "Fractional aggregations only supported for datasets with 1000m resolution. Using `intersects` as predicate"
+                )
+                predicate = "intersects"
+            else:
+                gdf_pop = handler.load_into_geodataframe(self.zone_gdf)
+
+                result = self.map_polygons(
+                    gdf_pop,
+                    value_columns="pixel_value",
+                    aggregation="sum",
+                    predicate="fractional",
+                )
+
+                self.add_variable_to_view(result, output_column)
+                return self.view
+
+        return self.map_ghsl(
+            handler=handler, stat=stat, output_column=output_column, **kwargs
+        )
+
+    def map_wp_pop(
+        self,
+        country: Union[str, List[str]],
+        resolution=1000,
+        predicate: Literal["intersects", "fractional"] = "intersects",
+        output_column: str = "population",
+        **kwargs,
+    ):
+        if isinstance(country, str):
+            country = [country]
+
+        handler = WPPopulationHandler(
+            project="pop", resolution=resolution, data_store=self.data_store, **kwargs
+        )
+
+        self.logger.info(
+            f"Mapping WorldPop Population data (year: {handler.config.year}, resolution: {handler.config.resolution}m)"
+        )
+
+        if predicate == "fractional":
+            if resolution == 100:
+                self.logger.warning(
+                    "Fractional aggregations only supported for datasets with 1000m resolution. Using `intersects` as predicate"
+                )
+                predicate = "intersects"
+            else:
+                gdf_pop = pd.concat(
+                    [
+                        handler.load_into_geodataframe(
+                            c, ensure_available=self.config.ensure_available
+                        )
+                        for c in country
+                    ],
+                    ignore_index=True,
+                )
+
+                result = self.map_polygons(
+                    gdf_pop,
+                    value_columns="pixel_value",
+                    aggregation="sum",
+                    predicate=predicate,
+                )
+
+                self.add_variable_to_view(result, output_column)
+                return self.view
+
+        tif_processors = []
+        for c in country:
+            tif_processors.extend(
+                handler.load_data(c, ensure_available=self.config.ensure_available)
+            )
+
+        self.logger.info(f"Sampling WorldPop Population data using 'sum' statistic")
+        sampled_values = self.map_rasters(tif_processors=tif_processors, stat="sum")
+
+        self.add_variable_to_view(sampled_values, output_column)
 
-        return self._zone_gdf.copy()
+        return self.view

gigaspatial/generators/zonal/mercator.py

@@ -15,25 +15,48 @@ from gigaspatial.generators.zonal.geometry import GeometryBasedZonalViewGenerato
 
 
 class MercatorViewGenerator(GeometryBasedZonalViewGenerator[T]):
-    """Mid-level class for zonal view generation based on geometries with identifiers.
+    """
+    Generates zonal views using Mercator tiles as the zones.
 
-    This class serves as an intermediate between the abstract ZonalViewGenerator and specific
-    implementations like MercatorViewGenerator or H3ViewGenerator. It handles the common case
-    where zones are defined by a mapping between zone identifiers and geometries, either
-    provided as a dictionary or as a GeoDataFrame.
+    This class specializes in creating zonal views where the zones are defined by
+    Mercator tiles. It extends the `GeometryBasedZonalViewGenerator` and leverages
+    the `MercatorTiles` and `CountryMercatorTiles` classes to generate tiles based on
+    various input sources.
 
-    The class extends the base functionality with methods for mapping common geospatial
-    datasets including GHSL (Global Human Settlement Layer), Google Open Buildings,
-    and Microsoft Global Buildings data.
+    The primary input source defines the geographical area of interest. This can be
+    a country, a specific geometry, a set of points, or even a list of predefined
+    quadkeys. The `zoom_level` determines the granularity of the Mercator tiles.
 
     Attributes:
-        zone_dict (Dict[T, Polygon]): Mapping of zone identifiers to geometries.
-        zone_id_column (str): Name of the column containing zone identifiers.
-        zone_data_crs (str): Coordinate reference system of the zone data.
-        _zone_gdf (gpd.GeoDataFrame): Cached GeoDataFrame representation of zones.
-        data_store (DataStore): For accessing input data.
-        generator_config (ZonalViewGeneratorConfig): Configuration for view generation.
-        logger: Logger instance for this class.
+        source (Union[str, BaseGeometry, gpd.GeoDataFrame, List[Union[Point, Tuple[float, float]]], List[str]]):
+            Specifies the geographic area or specific tiles to use. Can be:
+            - A country name (str): Uses `CountryMercatorTiles` to generate tiles covering the country.
+            - A Shapely geometry (BaseGeometry):  Uses `MercatorTiles.from_spatial` to create tiles intersecting the geometry.
+            - A GeoDataFrame (gpd.GeoDataFrame): Uses `MercatorTiles.from_spatial` to create tiles intersecting the geometries.
+            - A list of points (List[Union[Point, Tuple[float, float]]]):  Uses `MercatorTiles.from_spatial` to create tiles containing the points.
+            - A list of quadkeys (List[str]): Uses `MercatorTiles.from_quadkeys` to use the specified tiles directly.
+        zoom_level (int): The zoom level of the Mercator tiles. Higher zoom levels result in smaller, more detailed tiles.
+        predicate (str):  The spatial predicate used when filtering tiles based on a spatial source (e.g., "intersects", "contains"). Defaults to "intersects".
+        config (Optional[ZonalViewGeneratorConfig]): Configuration for the zonal view generation process.
+        data_store (Optional[DataStore]):  A DataStore instance for accessing data.
+        logger (Optional[logging.Logger]):  A logger instance for logging.
+
+    Methods:
+        _init_zone_data(source, zoom_level, predicate):  Initializes the Mercator tile GeoDataFrame based on the input source.
+        # Inherits other methods from GeometryBasedZonalViewGenerator, such as:
+        # map_ghsl(), map_google_buildings(), map_ms_buildings(), aggregate_data(), save_view()
+
+    Example:
+        # Create a MercatorViewGenerator for tiles covering Germany at zoom level 6
+        generator = MercatorViewGenerator(source="Germany", zoom_level=6)
+
+        # Create a MercatorViewGenerator for tiles intersecting a specific polygon
+        polygon = ... # Define a Shapely Polygon
+        generator = MercatorViewGenerator(source=polygon, zoom_level=8)
+
+        # Create a MercatorViewGenerator from a list of quadkeys
+        quadkeys = ["0020023131023032", "0020023131023033"]
+        generator = MercatorViewGenerator(source=quadkeys, zoom_level=12)
     """
 
     def __init__(
@@ -53,16 +76,19 @@ class MercatorViewGenerator(GeometryBasedZonalViewGenerator[T]):
     ):
 
         super().__init__(
-            zone_data=self._init_zone_data(source, zoom_level, predicate),
+            zone_data=self._init_zone_data(source, zoom_level, predicate, data_store),
             zone_id_column="quadkey",
             config=config,
             data_store=data_store,
             logger=logger,
         )
+        self.logger.info(f"Initialized MercatorViewGenerator")
 
-    def _init_zone_data(self, source, zoom_level, predicate):
+    def _init_zone_data(self, source, zoom_level, predicate, data_store=None):
         if isinstance(source, str):
-            tiles = CountryMercatorTiles.create(country=source, zoom_level=zoom_level)
+            tiles = CountryMercatorTiles.create(
+                country=source, zoom_level=zoom_level, data_store=data_store
+            )
         elif isinstance(source, (BaseGeometry, Iterable)):
             if isinstance(source, Iterable) and all(
                 isinstance(qk, str) for qk in source
@@ -73,6 +99,11 @@ class MercatorViewGenerator(GeometryBasedZonalViewGenerator[T]):
                     source=source, zoom_level=zoom_level, predicate=predicate
                 )
         else:
-            raise ValueError("sadadasfasfkasmf")
+            raise TypeError(
+                f"Unsupported source type for MercatorViewGenerator. 'source' must be "
+                f"a country name (str), a Shapely geometry, a GeoDataFrame, "
+                f"a list of quadkeys (str), or a list of (lon, lat) tuples/Shapely Point objects. "
+                f"Received type: {type(source)}."
+            )
 
         return tiles.to_geodataframe()

gigaspatial/grid/__init__.py

@@ -1 +1 @@
-from gigaspatial.grid.mercator_tiles import *
+from gigaspatial.grid.mercator_tiles import MercatorTiles, CountryMercatorTiles

gigaspatial/grid/mercator_tiles.py

@@ -4,10 +4,10 @@ import mercantile
 from shapely.geometry import box
 from shapely.geometry.base import BaseGeometry
 from shapely.strtree import STRtree
-from shapely import MultiPolygon, Polygon, Point
+from shapely import Point
 import json
 from pathlib import Path
-from pydantic import BaseModel, Field, PrivateAttr
+from pydantic import BaseModel, Field
 from typing import List, Union, Iterable, Optional, Tuple, ClassVar
 import pycountry
 
@@ -31,6 +31,9 @@ class MercatorTiles(BaseModel):
         if not quadkeys:
             cls.logger.warning("No quadkeys provided to from_quadkeys.")
             return cls(zoom_level=0, quadkeys=[])
+        cls.logger.info(
+            f"Initializing MercatorTiles from {len(quadkeys)} provided quadkeys."
+        )
         return cls(zoom_level=len(quadkeys[0]), quadkeys=set(quadkeys))
 
     @classmethod
@@ -120,14 +123,7 @@ class MercatorTiles(BaseModel):
         cls.logger.info(
             f"Creating MercatorTiles from {len(points)} points at zoom level: {zoom_level}"
         )
-        quadkeys = {
-            (
-                mercantile.quadkey(mercantile.tile(p.x, p.y, zoom_level))
-                if isinstance(p, Point)
-                else mercantile.quadkey(mercantile.tile(p[1], p[0], zoom_level))
-            )
-            for p in points
-        }
+        quadkeys = set(cls.get_quadkeys_from_points(points, zoom_level))
         cls.logger.info(f"Generated {len(quadkeys)} unique quadkeys from points.")
         return cls(zoom_level=zoom_level, quadkeys=list(quadkeys), **kwargs)
 
@@ -219,6 +215,29 @@ class MercatorTiles(BaseModel):
             {"quadkey": self.quadkeys, "geometry": self.to_geoms()}, crs="EPSG:4326"
         )
 
+    @staticmethod
+    def get_quadkeys_from_points(
+        points: List[Union[Point, Tuple[float, float]]], zoom_level: int
+    ) -> List[str]:
+        """Get list of quadkeys for the provided points at specified zoom level.
+
+        Args:
+            points: List of points as either shapely Points or (lon, lat) tuples
+            zoom_level: Zoom level for the quadkeys
+
+        Returns:
+            List of quadkey strings
+        """
+        quadkeys = [
+            (
+                mercantile.quadkey(mercantile.tile(p.x, p.y, zoom_level))
+                if isinstance(p, Point)
+                else mercantile.quadkey(mercantile.tile(p[1], p[0], zoom_level))
+            )
+            for p in points
+        ]
+        return quadkeys
+
     def save(self, file: Union[str, Path], format: str = "json") -> None:
         """Save MercatorTiles to file in specified format."""
         with self.data_store.open(str(file), "wb" if format == "parquet" else "w") as f:
@@ -270,6 +289,10 @@ class CountryMercatorTiles(MercatorTiles):
             country=pycountry.countries.lookup(country).alpha_3,
         )
 
+        cls.logger.info(
+            f"Initializing Mercator zones for country: {country} at zoom level {zoom_level}"
+        )
+
         country_geom = (
             AdminBoundaries.create(
                 country_code=country,

gigaspatial/handlers/__init__.py

@@ -21,7 +21,14 @@ from gigaspatial.handlers.osm import OSMLocationFetcher
 from gigaspatial.handlers.overture import OvertureAmenityFetcher
 from gigaspatial.handlers.mapbox_image import MapboxImageDownloader
 from gigaspatial.handlers.maxar_image import MaxarConfig, MaxarImageDownloader
-from gigaspatial.handlers.worldpop import WorldPopConfig, WorldPopDownloader
+
+from gigaspatial.handlers.worldpop import (
+    WPPopulationConfig,
+    WPPopulationReader,
+    WPPopulationDownloader,
+    WPPopulationHandler,
+    WorldPopRestClient,
+)
 from gigaspatial.handlers.ookla_speedtest import (
     OoklaSpeedtestTileConfig,
     OoklaSpeedtestConfig,

gigaspatial/handlers/base.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, List, Optional, Union, Tuple, Callable, Iterable
 import pandas as pd
@@ -13,7 +14,6 @@ from gigaspatial.core.io.data_store import DataStore
 from gigaspatial.core.io.local_data_store import LocalDataStore
 from gigaspatial.core.io.readers import read_dataset
 from gigaspatial.processing.tif_processor import TifProcessor
-from dataclasses import dataclass, field
 
 
 @dataclass
@@ -584,6 +584,8 @@ class BaseHandler(ABC):
             bool: True if data is available after this operation
         """
         try:
+            data_units = None
+            data_paths = None
             # Resolve what data units are needed
             if hasattr(self.config, "get_relevant_data_units"):
                 data_units = self.config.get_relevant_data_units(source, **kwargs)
@@ -606,11 +608,29 @@ class BaseHandler(ABC):
                 if not missing_paths:
                     self.logger.info("All required data is already available")
                     return True
-
-            # Download missing or all data
-            if hasattr(self.config, "get_relevant_data_units"):
-                data_units = self.config.get_relevant_data_units(source, **kwargs)
-                self.downloader.download_data_units(data_units, **kwargs)
+            else:
+                # If force_download, treat all as missing
+                missing_paths = data_paths
+
+            if not missing_paths:
+                self.logger.info("No missing data to download.")
+                return True
+
+            # Download logic
+            if data_units is not None:
+                # Map data_units to their paths and select only those that are missing
+                unit_to_path = dict(zip(data_units, data_paths))
+                if force_download:
+                    # Download all units if force_download
+                    self.downloader.download_data_units(data_units, **kwargs)
+                else:
+                    missing_units = [
+                        unit
+                        for unit, path in unit_to_path.items()
+                        if path in missing_paths
+                    ]
+                    if missing_units:
+                        self.downloader.download_data_units(missing_units, **kwargs)
             else:
                 self.downloader.download(source, **kwargs)