PyGeoFetch 1.0.3__tar.gz → 1.0.5__tar.gz

{pygeofetch-1.0.3 → pygeofetch-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 1.0.3
+Version: 1.0.5
 Summary: Universal satellite data pipeline — unified access to 22+ providers
 Author: PyGeoFetch Contributors
 License: MIT License

{pygeofetch-1.0.3 → pygeofetch-1.0.5}/pygeofetch/__init__.py

@@ -1,5 +1,5 @@
 """
-PyGeoFetch v1.0.3 — Universal Satellite Data Pipeline.
+PyGeoFetch v1.0.5 — Universal Satellite Data Pipeline.
 
 Unified access to 22+ satellite data providers with a consistent
 Python API and CLI. Supports authentication management, federated search,
@@ -30,7 +30,7 @@ CLI::
     pygeofetch doctor
 """
 
-__version__ = "1.0.3"
+__version__ = "1.0.5"
 __author__ = "PyGeoFetch Contributors"
 __license__ = "MIT"
 

{pygeofetch-1.0.3 → pygeofetch-1.0.5}/pygeofetch/cli/main.py

@@ -1,5 +1,5 @@
 """
-PyGeoFetch CLI v1.0.3 main entry point.
+PyGeoFetch CLI v1.0.5 main entry point.
 
 Full command reference:
   pygeofetch auth       — credential management
@@ -59,7 +59,7 @@ def cli(ctx: click.Context, log_level: str, log_file: str, log_format: str,
         config_file: str) -> None:
     """
     \b
-    PyGeoFetch v1.0.3 — Universal Satellite Data Pipeline
+    PyGeoFetch v1.0.5 — Universal Satellite Data Pipeline
     ===========================================================
     Unified access to 22+ satellite data providers.
 

{pygeofetch-1.0.3 → pygeofetch-1.0.5}/pygeofetch/models/satellite_data.py

@@ -290,7 +290,7 @@ class SatelliteData(BaseModel):
         """
         item: Dict[str, Any] = {
             "type": "Feature",
-            "stac_version": "1.0.3",
+            "stac_version": "1.0.5",
             "stac_extensions": self.stac_extensions,
             "id": self.id,
             "geometry": self.geometry or self._bbox_to_geometry(),

{pygeofetch-1.0.3 → pygeofetch-1.0.5}/pygeofetch/providers/copernicus.py

@@ -9,7 +9,7 @@ Authentication:
     Free registration at https://dataspace.copernicus.eu
 
 Supported datasets:
-    - Sentinel-1 (SAR C-band)
+    - Sentinel-1 (SAR C-band, GRD + SLC)
     - Sentinel-2 (Multispectral, 10-60m)
     - Sentinel-3 (Ocean/Land colour, OLCI/SLSTR)
     - Sentinel-5P (Atmospheric composition)
@@ -32,8 +32,8 @@ Example::
         bbox=(-74.1, 40.6, -73.7, 40.9),
         start_date="2024-01-01",
         end_date="2024-03-01",
-        satellites=["Sentinel-2"],
-        cloud_cover_max=15,
+        satellites=["Sentinel-1"],
+        cloud_cover_max=100,
     ))
 """
 
@@ -89,14 +89,75 @@ class CopernicusProvider(AbstractBaseProvider):
     AUTH_URL = "https://identity.dataspace.copernicus.eu/auth/realms/CDSE/protocol/openid-connect/token"
     S3_ENDPOINT = "https://eodata.dataspace.copernicus.eu"
 
-    # Map user-friendly satellite names to CDSE collection names
+    # ── STAC collection ID → OData collection name + product type ─────────────
+    #
+    # ROOT CAUSE OF BUG: The original code did [c.upper() for c in query.collections]
+    # which turned "sentinel-1-grd" into "SENTINEL-1-GRD". The Copernicus OData API
+    # only accepts TOP-LEVEL collection names ("SENTINEL-1", "SENTINEL-2" etc.).
+    # The product type (GRD, SLC) is a separate OData attribute filter.
+    #
+    # STAC collection IDs (planetary_computer / dataspace STAC):
+    #   "sentinel-1-grd", "sentinel-1-slc"
+    # OData collection names:
+    #   "SENTINEL-1"  (plus productType attribute filter "GRD" or "SLC")
+    #
+    STAC_TO_ODATA_COLLECTION: Dict[str, str] = {
+        # Sentinel-1 — all product types map to the same OData collection
+        "sentinel-1-grd":     "SENTINEL-1",
+        "sentinel-1-slc":     "SENTINEL-1",
+        "sentinel-1-grd-cog": "SENTINEL-1",
+        "sentinel-1-ocn":     "SENTINEL-1",
+        "sentinel-1-rtc":     "SENTINEL-1",
+        "sentinel-1":         "SENTINEL-1",
+        # Sentinel-2
+        "sentinel-2-l2a":     "SENTINEL-2",
+        "sentinel-2-l1c":     "SENTINEL-2",
+        "sentinel-2":         "SENTINEL-2",
+        # Sentinel-3
+        "sentinel-3-olci":    "SENTINEL-3",
+        "sentinel-3-slstr":   "SENTINEL-3",
+        "sentinel-3":         "SENTINEL-3",
+        # Sentinel-5P
+        "sentinel-5p-tropomi": "SENTINEL-5P",
+        "sentinel-5p":         "SENTINEL-5P",
+        # Sentinel-6
+        "sentinel-6":         "SENTINEL-6",
+    }
+
+    # Infer OData productType from STAC collection ID.
+    # These are passed to the productType attribute filter automatically.
+    STAC_TO_PRODUCT_TYPE: Dict[str, Optional[str]] = {
+        "sentinel-1-grd":     "GRD",
+        "sentinel-1-slc":     "SLC",
+        "sentinel-1-grd-cog": "GRD-COG",
+        "sentinel-1-ocn":     "OCN",
+        "sentinel-1-rtc":     "GRD",   # RTC is derived from GRD
+        "sentinel-2-l2a":     None,     # Sentinel-2 uses processingLevel, not productType
+        "sentinel-2-l1c":     None,
+    }
+
+    # Map user-friendly satellite names to Copernicus OData collection codes
     SATELLITE_COLLECTION_MAP = {
-        "sentinel-1": "SENTINEL-1",
-        "sentinel-2": "SENTINEL-2",
-        "sentinel-3": "SENTINEL-3",
-        "sentinel-5": "SENTINEL-5P",
+        # Sentinel-1 — all platform variants map to the same OData collection
+        "sentinel-1":  "SENTINEL-1",
+        "sentinel-1a": "SENTINEL-1",
+        "sentinel-1b": "SENTINEL-1",
+        "sentinel-1c": "SENTINEL-1",   # active constellation (May 2025+)
+        "sentinel-1d": "SENTINEL-1",   # active constellation (Apr 2026+)
+        "s1a":         "SENTINEL-1",
+        "s1b":         "SENTINEL-1",
+        "s1c":         "SENTINEL-1",
+        "s1d":         "SENTINEL-1",
+        # Sentinel-2
+        "sentinel-2":  "SENTINEL-2",
+        "sentinel-2a": "SENTINEL-2",
+        "sentinel-2b": "SENTINEL-2",
+        "sentinel-2c": "SENTINEL-2",
+        # Sentinel-3, 5P, 6
+        "sentinel-3":  "SENTINEL-3",
+        "sentinel-5":  "SENTINEL-5P",
         "sentinel-5p": "SENTINEL-5P",
-        "sentinel-6": "SENTINEL-6",
+        "sentinel-6":  "SENTINEL-6",
     }
 
     def authenticate(self, credentials: Credentials) -> AuthSession:
@@ -200,12 +261,18 @@ class CopernicusProvider(AbstractBaseProvider):
         self.require_auth()
         self._refresh_token_if_needed()
 
-        collections = self._resolve_collections(query)
+        collections, inferred_product_type = self._resolve_collections(query)
         results: List[SatelliteData] = []
 
+        # If a product type was inferred from the STAC collection ID and the
+        # query doesn't already have one set, apply it as the search filter.
+        effective_product_type = getattr(query, "product_type", None) or inferred_product_type
+
         for collection in collections:
             try:
-                items = self._search_collection(collection, query)
+                items = self._search_collection(
+                    collection, query, product_type=effective_product_type
+                )
                 results.extend(items)
                 if len(results) >= query.max_results:
                     break
@@ -214,27 +281,111 @@ class CopernicusProvider(AbstractBaseProvider):
 
         return results[: query.max_results]
 
-    def _resolve_collections(self, query: SearchQuery) -> List[str]:
-        """Map query satellite names to Copernicus collection codes."""
-        if query.collections:
+    def _resolve_collections(
+        self, query: SearchQuery
+    ) -> tuple[List[str], Optional[str]]:
+        """
+        Map query satellite names or STAC collection IDs to OData collection names.
+
+        Returns:
+            (odata_collection_names, inferred_product_type)
+
+        ── Key fix ────────────────────────────────────────────────────────────
+        The original implementation did:
             return [c.upper() for c in query.collections]
 
-        if not query.satellites:
-            return ["SENTINEL-2"]  # sensible default
+        This turned "sentinel-1-grd" into "SENTINEL-1-GRD" — which the
+        Copernicus OData API rejects with HTTP 400 because the valid OData
+        collection name is "SENTINEL-1" (top-level). The product type (GRD,
+        SLC) is passed separately as an OData attribute filter.
+
+        Now we map STAC collection IDs → OData collection names and also
+        extract the product type so it is applied as a filter automatically.
+        ───────────────────────────────────────────────────────────────────────
+        """
+        inferred_product_type: Optional[str] = None
+
+        if query.collections:
+            resolved: set[str] = set()
+            for c in query.collections:
+                c_lower = c.lower().strip()
+
+                # Try exact STAC collection ID match first
+                if c_lower in self.STAC_TO_ODATA_COLLECTION:
+                    resolved.add(self.STAC_TO_ODATA_COLLECTION[c_lower])
+                    # Infer product type from STAC collection if not set
+                    pt = self.STAC_TO_PRODUCT_TYPE.get(c_lower)
+                    if pt and inferred_product_type is None:
+                        inferred_product_type = pt
+
+                # Already a valid OData collection name (user knew what they wanted)
+                elif c.upper() in ("SENTINEL-1", "SENTINEL-2", "SENTINEL-3",
+                                   "SENTINEL-5P", "SENTINEL-6"):
+                    resolved.add(c.upper())
+
+                # Prefix fallback: "sentinel-1-*" → SENTINEL-1
+                elif c_lower.startswith("sentinel-1") or c_lower.startswith("s1"):
+                    resolved.add("SENTINEL-1")
+                elif c_lower.startswith("sentinel-2") or c_lower.startswith("s2"):
+                    resolved.add("SENTINEL-2")
+                elif c_lower.startswith("sentinel-3") or c_lower.startswith("s3"):
+                    resolved.add("SENTINEL-3")
+                elif c_lower.startswith("sentinel-5") or c_lower.startswith("s5"):
+                    resolved.add("SENTINEL-5P")
+
+                else:
+                    # Unknown — pass through uppercased and log a warning
+                    self._logger.warning(
+                        "Unknown collection ID %r. Expected a STAC ID like "
+                        "'sentinel-1-grd' or an OData name like 'SENTINEL-1'. "
+                        "Passing through as-is — search may return 400.",
+                        c
+                    )
+                    resolved.add(c.upper())
+
+            return list(resolved), inferred_product_type
 
-        collections = set()
+        if not query.satellites:
+            # No collection, no satellite — use product_type to pick a default
+            pt = getattr(query, "product_type", None) or ""
+            if pt.upper() in ("SLC", "GRD", "GRD-COG", "OCN"):
+                return ["SENTINEL-1"], None
+            return ["SENTINEL-2"], None
+
+        # Resolve from satellite names
+        resolved_from_sat: set[str] = set()
         for sat in query.satellites:
-            sat_lower = sat.lower()
+            sat_lower = sat.lower().replace("-", "").replace("_", "").replace(" ", "")
+            sat_orig  = sat.lower()
+            matched = False
             for key, col in self.SATELLITE_COLLECTION_MAP.items():
-                if key in sat_lower:
-                    collections.add(col)
+                key_norm = key.replace("-", "").replace("_", "")
+                if key_norm == sat_lower or key in sat_orig or sat_orig.startswith(key):
+                    resolved_from_sat.add(col)
+                    matched = True
                     break
-            else:
-                collections.add(sat.upper())
-
-        return list(collections)
-
-    def _build_odata_filter(self, collection: str, query: SearchQuery) -> str:
+            if not matched:
+                if "sentinel-1" in sat_orig or sat_orig.startswith("s1"):
+                    resolved_from_sat.add("SENTINEL-1")
+                elif "sentinel-2" in sat_orig or sat_orig.startswith("s2"):
+                    resolved_from_sat.add("SENTINEL-2")
+                else:
+                    resolved_from_sat.add(sat.upper())
+
+        if not resolved_from_sat:
+            pt = getattr(query, "product_type", None) or ""
+            if pt.upper() in ("SLC", "GRD", "GRD-COG", "OCN"):
+                return ["SENTINEL-1"], None
+            return ["SENTINEL-2"], None
+
+        return list(resolved_from_sat), inferred_product_type
+
+    def _build_odata_filter(
+        self,
+        collection: str,
+        query: SearchQuery,
+        product_type: Optional[str] = None,
+    ) -> str:
         """Build OData $filter string for the given collection and query."""
         filters = [f"Collection/Name eq '{collection}'"]
 
@@ -255,30 +406,77 @@ class CopernicusProvider(AbstractBaseProvider):
             )
             filters.append(f"OData.CSC.Intersects(area=geography'SRID=4326;{polygon}')")
 
-        if (query.cloud_cover_max or 100) < 100:
-            filters.append(f"Attributes/OData.CSC.DoubleAttribute/any(att:att/Name eq 'cloudCover' and att/OData.CSC.DoubleAttribute/Value le {query.cloud_cover_max})")
-        if getattr(query, 'cloud_cover_min', 0) > 0:
-            filters.append(f"Attributes/OData.CSC.DoubleAttribute/any(att:att/Name eq 'cloudCover' and att/OData.CSC.DoubleAttribute/Value ge {getattr(query, 'cloud_cover_min', 0)})")
+        # Cloud cover — only meaningful for optical (Sentinel-2/3)
+        # Sentinel-1 SAR has no cloud cover — skip filter to avoid empty results
+        is_sar = collection == "SENTINEL-1"
+        if not is_sar and (query.cloud_cover_max or 100) < 100:
+            filters.append(
+                f"Attributes/OData.CSC.DoubleAttribute/any("
+                f"att:att/Name eq 'cloudCover' and "
+                f"att/OData.CSC.DoubleAttribute/Value le {query.cloud_cover_max})"
+            )
+        if not is_sar and getattr(query, "cloud_cover_min", 0) > 0:
+            filters.append(
+                f"Attributes/OData.CSC.DoubleAttribute/any("
+                f"att:att/Name eq 'cloudCover' and "
+                f"att/OData.CSC.DoubleAttribute/Value ge {getattr(query, 'cloud_cover_min', 0)})"
+            )
 
-        # Processing level filter
+        # Processing level filter (Sentinel-2: L1C, L2A)
         if query.processing_levels:
             level_filter = " or ".join(
-                f"Attributes/OData.CSC.StringAttribute/any(att:att/Name eq 'processingLevel' and att/OData.CSC.StringAttribute/Value eq '{level}')"
+                f"Attributes/OData.CSC.StringAttribute/any("
+                f"att:att/Name eq 'processingLevel' and "
+                f"att/OData.CSC.StringAttribute/Value eq '{level}')"
                 for level in query.processing_levels
             )
             filters.append(f"({level_filter})")
 
+        # Product type filter — GRD, SLC, GRD-COG, OCN (Sentinel-1)
+        # product_type comes from either the query directly or was inferred
+        # from the STAC collection ID (e.g. "sentinel-1-grd" → "GRD")
+        effective_pt = product_type or getattr(query, "product_type", None)
+        if effective_pt:
+            filters.append(
+                f"Attributes/OData.CSC.StringAttribute/any("
+                f"att:att/Name eq 'productType' and "
+                f"att/OData.CSC.StringAttribute/Value eq '{effective_pt.upper()}')"
+            )
+
+        # Polarisation filter (VV+VH, HH, etc.)
+        pol = getattr(query, "polarisation", None)
+        if pol:
+            filters.append(
+                f"Attributes/OData.CSC.StringAttribute/any("
+                f"att:att/Name eq 'polarisationChannels' and "
+                f"att/OData.CSC.StringAttribute/Value eq '{pol.upper()}')"
+            )
+
+        # Pass direction filter (ASCENDING / DESCENDING)
+        pass_dir = getattr(query, "pass_direction", None)
+        if pass_dir:
+            filters.append(
+                f"Attributes/OData.CSC.StringAttribute/any("
+                f"att:att/Name eq 'orbitDirection' and "
+                f"att/OData.CSC.StringAttribute/Value eq '{pass_dir.upper()}')"
+            )
+
         return " and ".join(filters)
 
-    def _search_collection(self, collection: str, query: SearchQuery) -> List[SatelliteData]:
+    def _search_collection(
+        self,
+        collection: str,
+        query: SearchQuery,
+        product_type: Optional[str] = None,
+    ) -> List[SatelliteData]:
         """Perform OData search for a specific collection."""
         import httpx
 
         params: Dict[str, Any] = {
-            "$filter": self._build_odata_filter(collection, query),
+            "$filter":  self._build_odata_filter(collection, query, product_type),
             "$orderby": "ContentDate/Start desc",
-            "$top": min(query.max_results, 1000),
-            "$expand": "Attributes",
+            "$top":     min(query.max_results, 1000),
+            "$expand":  "Attributes",
         }
 
         response = httpx.get(
@@ -294,7 +492,7 @@ class CopernicusProvider(AbstractBaseProvider):
     def _product_to_satellite_data(self, product: Dict) -> SatelliteData:
         """Convert a Copernicus OData product dict to SatelliteData."""
         product_id = product.get("Id", "")
-        name = product.get("Name", "")
+        name       = product.get("Name", "")
         collection = product.get("S3Path", "").split("/")[2] if product.get("S3Path") else ""
 
         # Parse footprint
@@ -322,7 +520,7 @@ class CopernicusProvider(AbstractBaseProvider):
             except Exception:
                 pass
 
-        # Extract attributes
+        # Extract attributes from OData $expand=Attributes
         attributes = {
             a.get("Name"): a.get("Value")
             for a in (product.get("Attributes") or [])
@@ -334,9 +532,19 @@ class CopernicusProvider(AbstractBaseProvider):
             except (ValueError, TypeError):
                 cloud_cover = None
 
-        # Determine satellite from name
+        # Determine satellite platform from product name
+        # (e.g. S1C_IW_SLC → Sentinel-1C)
         satellite = "Sentinel"
-        if name.startswith("S1"):
+        platform  = attributes.get("platform") or attributes.get("platformShortName", "")
+        if name.startswith("S1C") or "SENTINEL-1C" in platform.upper():
+            satellite = "SENTINEL-1C"
+        elif name.startswith("S1D") or "SENTINEL-1D" in platform.upper():
+            satellite = "SENTINEL-1D"
+        elif name.startswith("S1A") or "SENTINEL-1A" in platform.upper():
+            satellite = "SENTINEL-1A"
+        elif name.startswith("S1B") or "SENTINEL-1B" in platform.upper():
+            satellite = "SENTINEL-1B"
+        elif name.startswith("S1"):
             satellite = "Sentinel-1"
         elif name.startswith("S2"):
             satellite = "Sentinel-2"
@@ -345,7 +553,41 @@ class CopernicusProvider(AbstractBaseProvider):
         elif name.startswith("S5P"):
             satellite = "Sentinel-5P"
 
-        # Build assets
+        # SAR-specific attributes (all from OData $expand=Attributes)
+        product_type    = attributes.get("productType")           # "SLC", "GRD", "GRD-COG"
+        polarisation    = attributes.get("polarisationChannels")  # "VV VH", "HH", etc.
+        pass_direction  = attributes.get("orbitDirection")        # "ASCENDING", "DESCENDING"
+        rel_orbit       = attributes.get("relativeOrbitNumber")
+        abs_orbit       = attributes.get("absoluteOrbitNumber")
+        incidence_angle = attributes.get("incidenceAngleMax")
+
+        # Normalise polarisation string: "VV VH" → "VV+VH"
+        if polarisation:
+            polarisation = polarisation.strip().replace(" ", "+")
+
+        # Normalise pass direction to lowercase: "ASCENDING" → "ascending"
+        if pass_direction:
+            pass_direction = pass_direction.lower()
+
+        # Parse numeric fields
+        try:
+            rel_orbit = int(rel_orbit) if rel_orbit is not None else None
+        except (ValueError, TypeError):
+            rel_orbit = None
+        try:
+            abs_orbit = int(abs_orbit) if abs_orbit is not None else None
+        except (ValueError, TypeError):
+            abs_orbit = None
+        try:
+            incidence_angle = float(incidence_angle) if incidence_angle is not None else None
+        except (ValueError, TypeError):
+            incidence_angle = None
+
+        # GSD from product type
+        gsd_map = {"SLC": 5.0, "GRD": 10.0, "GRD-COG": 10.0, "OCN": None}
+        gsd_m = gsd_map.get(product_type or "", None)
+
+        # Build assets dict
         assets: Dict[str, SatelliteAsset] = {}
         s3_path = product.get("S3Path")
         if s3_path:
@@ -384,10 +626,19 @@ class CopernicusProvider(AbstractBaseProvider):
             processing_level=proc_level,
             assets=assets,
             properties={
-                "name": name,
+                "name":    name,
                 "s3_path": s3_path,
                 **attributes,
             },
+            # SAR / platform metadata fields
+            product_type    = product_type,
+            polarisation    = polarisation,
+            pass_direction  = pass_direction,
+            relative_orbit  = rel_orbit,
+            orbit_number    = abs_orbit,
+            incidence_angle = incidence_angle,
+            gsd_m           = gsd_m,
+            resolution_m    = gsd_m,
         )
 
     def download(
@@ -400,9 +651,9 @@ class CopernicusProvider(AbstractBaseProvider):
         Download a Copernicus product via authenticated HTTPS.
 
         Args:
-            data: SatelliteData to download.
+            data:        SatelliteData to download.
             destination: Output directory.
-            options: Download configuration.
+            options:     Download configuration.
 
         Returns:
             DownloadResult.
@@ -438,10 +689,12 @@ class CopernicusProvider(AbstractBaseProvider):
             ) as resp:
                 self._handle_http_error(resp)
                 with open(output_file, "wb") as f:
-                    for chunk in resp.iter_bytes(chunk_size=int(options.chunk_size_mb * 1024 * 1024)):
+                    for chunk in resp.iter_bytes(
+                        chunk_size=int(options.chunk_size_mb * 1024 * 1024)
+                    ):
                         f.write(chunk)
 
-            duration = time.time() - start_time
+            duration  = time.time() - start_time
             file_size = output_file.stat().st_size
 
             return DownloadResult(
@@ -472,7 +725,9 @@ class CopernicusProvider(AbstractBaseProvider):
             streaming=True,
             stac=False,
             requires_auth=True,
-            supported_satellites=["Sentinel-1", "Sentinel-2", "Sentinel-3", "Sentinel-5P", "Sentinel-6"],
+            supported_satellites=[
+                "Sentinel-1", "Sentinel-2", "Sentinel-3", "Sentinel-5P", "Sentinel-6"
+            ],
             supported_formats=[DataFormat.SAFE, DataFormat.GEOTIFF, DataFormat.ZIP],
             supports_cloud_filter=True,
             supports_date_filter=True,

{pygeofetch-1.0.3 → pygeofetch-1.0.5}/pygeofetch/providers/sentinel_hub.py

@@ -107,7 +107,7 @@ class SentinelHubProvider(AbstractBaseProvider):
             payload["filter"] = {"maxCloudCoverage": query.cloud_cover_max}
         try:
             resp = httpx.post(
-                f"{self.BASE_URL}/api/v1/catalog/1.0.3/search",
+                f"{self.BASE_URL}/api/v1/catalog/1.0.5/search",
                 json=payload, headers={"Authorization": f"Bearer {self._session.access_token}"},
                 timeout=self.config.get("timeout", 60),
             )

{pygeofetch-1.0.3 → pygeofetch-1.0.5}/pygeofetch.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 1.0.3
+Version: 1.0.5
 Summary: Universal satellite data pipeline — unified access to 22+ providers
 Author: PyGeoFetch Contributors
 License: MIT License

{pygeofetch-1.0.3 → pygeofetch-1.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygeofetch"
-version = "1.0.3"
+version = "1.0.5"
 description = "Universal satellite data pipeline — unified access to 22+ providers"
 readme = "README.md"
 license = { file = "LICENSE" }