satcube 0.1.0__tar.gz → 0.1.1__tar.gz

satcube-0.1.1/PKG-INFO

@@ -0,0 +1,224 @@
+Metadata-Version: 2.1
+Name: satcube
+Version: 0.1.1
+Summary: A Python package to create cloud-free monthly composites by fusing Landsat and Sentinel-2 data.
+Home-page: https://github.com/IPL-UV/satcube
+Author: Cesar Aybar
+Author-email: fcesar.aybar@uv.es
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: full
+Requires-Dist: cubexpress (>=0.1.2)
+Requires-Dist: earthengine-api (>=0.1.4.0) ; extra == "full"
+Requires-Dist: fastcubo (>=0.0.999)
+Requires-Dist: mlstac (>=0.5.0)
+Requires-Dist: numpy (>=1.25.0)
+Requires-Dist: pandas (>=2.0.0)
+Requires-Dist: pydantic (>=2.8.0)
+Requires-Dist: rasterio (>=1.2.0) ; extra == "full"
+Requires-Dist: requests (>=2.26.0)
+Requires-Dist: satalign (>=0.0.999)
+Requires-Dist: scikit-learn (>=1.2.0) ; extra == "full"
+Requires-Dist: segmentation-models-pytorch (>=0.3.0) ; extra == "full"
+Requires-Dist: torch (>=2.0.0) ; extra == "full"
+Requires-Dist: xarray (>=2023.7.0)
+Project-URL: Documentation, https://ipl-uv.github.io/satcube/
+Project-URL: Repository, https://github.com/IPL-UV/satcube
+Description-Content-Type: text/markdown
+
+# 
+
+<p align="center">
+  <img src="https://huggingface.co/datasets/JulioContrerasH/DataMLSTAC/resolve/main/banner_satcube.png" width="33%">
+</p>
+
+<p align="center">
+    <em>A Python package for managing Sentinel-2 satellite data cubes</em> 🚀
+</p>
+
+<p align="center">
+<a href='https://pypi.python.org/pypi/satcube'>
+    <img src='https://img.shields.io/pypi/v/satcube.svg' alt='PyPI' />
+</a>
+<a href="https://opensource.org/licenses/MIT" target="_blank">
+    <img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License">
+</a>
+<a href="https://github.com/psf/black" target="_blank">
+    <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Black">
+</a>
+<a href="https://pycqa.github.io/isort/" target="_blank">
+    <img src="https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336" alt="isort">
+</a>
+</p>
+
+---
+
+**GitHub**: [https://github.com/IPL-UV/satcube](https://github.com/IPL-UV/satcube) 🌐
+
+**PyPI**: [https://pypi.org/project/satcube/](https://pypi.org/project/satcube/) 🛠️
+
+---
+
+## **Overview** 📊
+
+**satcube** is a Python package designed for efficient management, processing, and analysis of Sentinel-2 satellite image cubes. It allows for downloading, cloud masking, gap filling, and super-resolving Sentinel-2 imagery, as well as creating monthly composites and performing interpolation.
+
+## **Key Features** ✨
+- **Satellite image download**: Retrieve Sentinel-2 images from Earth Engine efficiently. 🛰️
+- **Cloud masking**: Automatically remove clouds from Sentinel-2 images. ☁️
+- **Gap filling**: Fill missing data using methods like linear interpolation and histogram matching. 🧩
+- **Super-resolution**: Apply super-resolution models to enhance image quality. 🔍
+- **Monthly composites**: Aggregate images into monthly composites with various statistical methods. 📅
+- **Temporal smoothing**: Smooth reflectance values across time using interpolation techniques. 📈
+## **Installation** ⚙️
+
+Install the latest version from PyPI:
+
+```bash
+pip install satcube
+```
+
+## **How to use** 🛠️
+
+### **Basic usage: working with sentinel-2 data** 🌍
+
+#### **Load libraries**
+
+```python
+import ee
+import satcube
+```
+
+#### **Authenticate and initialize earth engine**
+
+```python
+ee.Authenticate()
+ee.Initialize(project="ee-csaybar-real")
+```
+#### **Download model weights**
+```python
+outpath = satcube.download_weights(path="weights")
+```
+
+#### **Create a satellite dataCube**
+```python
+datacube = satcube.SatCube(
+    coordinates=(-77.68598590138802,-8.888223962022263),
+    sensor=satcube.Sentinel2(weight_path=outpath, edge_size=384),
+    output_dir="wendy01",
+    max_workers=12,
+    device="cuda",
+)
+```
+
+
+### **Query and process sentinel-2 data** 🛰️
+
+#### **Query the sentinel-2 image collection**
+
+```python
+# Query the Sentinel-2 image collection
+table_query = datacube.metadata_s2()
+
+# Filter images based on cloud cover and remove duplicates
+table_query_subset = table_query[table_query["cs_cdf"] > 0.30]
+table_query_subset = table_query_subset.drop_duplicates(subset="img_date")
+mgrs_tile_max = table_query_subset["mgrs_title"].value_counts().idxmax()
+table_query_subset = table_query_subset[table_query_subset["mgrs_title"] == mgrs_tile_max]
+```
+
+#### **Download sentinel-2 images**
+
+```python
+table_download = datacube.download_s2_image(table_query_subset)
+```
+#### **Cloud masking**
+
+```python
+# Remove clouds from the images
+table_nocloud = datacube.cloudmasking_s2(table_download)
+table_nocloud = table_nocloud[table_nocloud["cloud_cover"] < 0.75]
+table_nocloud.reset_index(drop=True, inplace=True)
+```
+
+#### **Gap filling**
+
+```python
+# Fill missing data in the images
+table_nogaps = datacube.gapfilling_s2(table_nocloud)
+table_nogaps = table_nogaps[table_nogaps["match_error"] < 0.1]
+```
+### **Monthly composites and image smoothing 📅**
+
+#### **Create monthly composites**
+
+```python
+# Generate monthly composites
+table_composites = datacube.monthly_composites_s2(
+    table_nogaps, agg_method="median", date_range=("2016-01-01", "2024-07-31")
+)
+```
+
+#### **Interpolate missing data**
+
+```python
+# Interpolate missing months if necessary
+table_interpolate = datacube.interpolate_s2(table=table_composites)
+```
+
+#### **Smooth reflectance values**
+
+```python
+# Smooth reflectance values across time
+table_smooth = datacube.smooth_s2(table=table_interpolate)
+```
+
+### **Super-resolution and visualization** 📐
+
+
+
+#### **Super-resolution**
+
+```python
+# Apply super-resolution to the image cube
+# table_final = datacube.super_s2(table_smooth)
+```
+
+
+#### **Display images**
+
+```python
+# Display the images from the data cube
+datacube.display_images(table=table_smooth)
+```
+
+#### **Create a GIF**
+
+```python
+# !apt-get install imagemagick
+import os
+os.system("convert -delay 20 -loop 0 wendy01/z_s2_07_smoothed_png/temp_07*.png animation.gif")
+
+from IPython.display import Image
+Image(filename='animation.gif', width=500)
+```
+
+<p align="center">
+  <img src="https://huggingface.co/datasets/JulioContrerasH/DataMLSTAC/resolve/main/gif_satcube.gif" width="100%">
+</p>
+
+#### **Smooth reflectance values**
+
+```python
+# Smooth reflectance values across time
+table_smooth = datacube.smooth_s2(table=table_interpolate)
+```
+
+## **Supported features and filters** ✨
+
+- **Cloud masking:** Efficient removal of clouds from satellite images.
+- **Resampling methods:** Various methods for resampling and aligning imagery.
+- **Super-resolution:** ONNX-based models for improving image resolution.

satcube-0.1.1/README.md

@@ -0,0 +1,193 @@
+# 
+
+<p align="center">
+  <img src="https://huggingface.co/datasets/JulioContrerasH/DataMLSTAC/resolve/main/banner_satcube.png" width="33%">
+</p>
+
+<p align="center">
+    <em>A Python package for managing Sentinel-2 satellite data cubes</em> 🚀
+</p>
+
+<p align="center">
+<a href='https://pypi.python.org/pypi/satcube'>
+    <img src='https://img.shields.io/pypi/v/satcube.svg' alt='PyPI' />
+</a>
+<a href="https://opensource.org/licenses/MIT" target="_blank">
+    <img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License">
+</a>
+<a href="https://github.com/psf/black" target="_blank">
+    <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Black">
+</a>
+<a href="https://pycqa.github.io/isort/" target="_blank">
+    <img src="https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336" alt="isort">
+</a>
+</p>
+
+---
+
+**GitHub**: [https://github.com/IPL-UV/satcube](https://github.com/IPL-UV/satcube) 🌐
+
+**PyPI**: [https://pypi.org/project/satcube/](https://pypi.org/project/satcube/) 🛠️
+
+---
+
+## **Overview** 📊
+
+**satcube** is a Python package designed for efficient management, processing, and analysis of Sentinel-2 satellite image cubes. It allows for downloading, cloud masking, gap filling, and super-resolving Sentinel-2 imagery, as well as creating monthly composites and performing interpolation.
+
+## **Key Features** ✨
+- **Satellite image download**: Retrieve Sentinel-2 images from Earth Engine efficiently. 🛰️
+- **Cloud masking**: Automatically remove clouds from Sentinel-2 images. ☁️
+- **Gap filling**: Fill missing data using methods like linear interpolation and histogram matching. 🧩
+- **Super-resolution**: Apply super-resolution models to enhance image quality. 🔍
+- **Monthly composites**: Aggregate images into monthly composites with various statistical methods. 📅
+- **Temporal smoothing**: Smooth reflectance values across time using interpolation techniques. 📈
+## **Installation** ⚙️
+
+Install the latest version from PyPI:
+
+```bash
+pip install satcube
+```
+
+## **How to use** 🛠️
+
+### **Basic usage: working with sentinel-2 data** 🌍
+
+#### **Load libraries**
+
+```python
+import ee
+import satcube
+```
+
+#### **Authenticate and initialize earth engine**
+
+```python
+ee.Authenticate()
+ee.Initialize(project="ee-csaybar-real")
+```
+#### **Download model weights**
+```python
+outpath = satcube.download_weights(path="weights")
+```
+
+#### **Create a satellite dataCube**
+```python
+datacube = satcube.SatCube(
+    coordinates=(-77.68598590138802,-8.888223962022263),
+    sensor=satcube.Sentinel2(weight_path=outpath, edge_size=384),
+    output_dir="wendy01",
+    max_workers=12,
+    device="cuda",
+)
+```
+
+
+### **Query and process sentinel-2 data** 🛰️
+
+#### **Query the sentinel-2 image collection**
+
+```python
+# Query the Sentinel-2 image collection
+table_query = datacube.metadata_s2()
+
+# Filter images based on cloud cover and remove duplicates
+table_query_subset = table_query[table_query["cs_cdf"] > 0.30]
+table_query_subset = table_query_subset.drop_duplicates(subset="img_date")
+mgrs_tile_max = table_query_subset["mgrs_title"].value_counts().idxmax()
+table_query_subset = table_query_subset[table_query_subset["mgrs_title"] == mgrs_tile_max]
+```
+
+#### **Download sentinel-2 images**
+
+```python
+table_download = datacube.download_s2_image(table_query_subset)
+```
+#### **Cloud masking**
+
+```python
+# Remove clouds from the images
+table_nocloud = datacube.cloudmasking_s2(table_download)
+table_nocloud = table_nocloud[table_nocloud["cloud_cover"] < 0.75]
+table_nocloud.reset_index(drop=True, inplace=True)
+```
+
+#### **Gap filling**
+
+```python
+# Fill missing data in the images
+table_nogaps = datacube.gapfilling_s2(table_nocloud)
+table_nogaps = table_nogaps[table_nogaps["match_error"] < 0.1]
+```
+### **Monthly composites and image smoothing 📅**
+
+#### **Create monthly composites**
+
+```python
+# Generate monthly composites
+table_composites = datacube.monthly_composites_s2(
+    table_nogaps, agg_method="median", date_range=("2016-01-01", "2024-07-31")
+)
+```
+
+#### **Interpolate missing data**
+
+```python
+# Interpolate missing months if necessary
+table_interpolate = datacube.interpolate_s2(table=table_composites)
+```
+
+#### **Smooth reflectance values**
+
+```python
+# Smooth reflectance values across time
+table_smooth = datacube.smooth_s2(table=table_interpolate)
+```
+
+### **Super-resolution and visualization** 📐
+
+
+
+#### **Super-resolution**
+
+```python
+# Apply super-resolution to the image cube
+# table_final = datacube.super_s2(table_smooth)
+```
+
+
+#### **Display images**
+
+```python
+# Display the images from the data cube
+datacube.display_images(table=table_smooth)
+```
+
+#### **Create a GIF**
+
+```python
+# !apt-get install imagemagick
+import os
+os.system("convert -delay 20 -loop 0 wendy01/z_s2_07_smoothed_png/temp_07*.png animation.gif")
+
+from IPython.display import Image
+Image(filename='animation.gif', width=500)
+```
+
+<p align="center">
+  <img src="https://huggingface.co/datasets/JulioContrerasH/DataMLSTAC/resolve/main/gif_satcube.gif" width="100%">
+</p>
+
+#### **Smooth reflectance values**
+
+```python
+# Smooth reflectance values across time
+table_smooth = datacube.smooth_s2(table=table_interpolate)
+```
+
+## **Supported features and filters** ✨
+
+- **Cloud masking:** Efficient removal of clouds from satellite images.
+- **Resampling methods:** Various methods for resampling and aligning imagery.
+- **Super-resolution:** ONNX-based models for improving image resolution.

satcube-0.1.1/pyproject.toml

@@ -0,0 +1,54 @@
+[tool.poetry]
+name    = "satcube"
+version = "0.1.1"
+description = "A Python package to create cloud-free monthly composites by fusing Landsat and Sentinel-2 data."
+authors = ["Cesar Aybar <fcesar.aybar@uv.es>"]
+repository     = "https://github.com/IPL-UV/satcube"
+documentation  = "https://ipl-uv.github.io/satcube/"
+readme         = "README.md"
+packages       = [{ include = "satcube" }]
+
+[tool.poetry.dependencies]
+python              = ">=3.10,<4.0"
+cubexpress          = ">=0.1.2"
+mlstac              = ">=0.5.0"
+fastcubo            = ">=0.0.999"
+satalign            = ">=0.0.999"
+torch               = ">=2.0.0"
+pandas              = ">=2.0.0"
+pydantic            = ">=2.8.0"
+earthengine-api     = ">=0.1.4.0"
+numpy               = ">=1.25.0"
+rasterio            = ">=1.2.0"
+requests            = ">=2.26.0"
+scikit-learn        = ">=1.2.0"
+segmentation-models-pytorch = ">=0.3.0"
+xarray              = ">=2023.7.0"
+
+[tool.poetry.extras]
+full = [
+  "torch",
+  "segmentation-models-pytorch",
+  "scikit-learn",
+  "rasterio",
+  "earthengine-api",
+  "fastparquet"
+]
+
+# --- tooling fixes ----------------------------------------------------------
+[tool.mypy]
+files                   = ["satcube"]
+disallow_untyped_defs   = true
+disallow_any_unimported = true
+no_implicit_optional    = true
+check_untyped_defs      = true
+warn_return_any         = true
+warn_unused_ignores     = true
+show_error_codes        = true
+
+[tool.ruff]
+target-version = "py310"
+line-length    = 120
+fix            = true
+select         = ["YTT","S","B","A","C4","T10","SIM","I","C90","E","W","F","PGH","UP","RUF","TRY"]
+ignore         = ["E501","E731"]

satcube-0.1.1/satcube/cloud_detection.py

@@ -0,0 +1,160 @@
+"""Predict cloud masks for Sentinel-2 GeoTIFFs with the SEN2CloudEnsemble model.
+
+The callable :pyfunc:`cloud_masking` accepts **either** a single ``.tif`` file  
+or a directory tree; in both cases it writes a masked copy of every image (and,
+optionally, the binary mask) to *output*.
+
+Example
+-------
+>>> from satcube.cloud_detection import cloud_masking
+>>> cloud_masking("~/s2/input", "~/s2/output", device="cuda")
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import List
+
+import mlstac
+import numpy as np
+import rasterio as rio
+import torch
+
+from satcube.utils import DeviceManager, _reset_gpu
+
+
+def cloud_masking(
+    input: str | Path,              # noqa: A002 (shadowing built-in is OK here)
+    output: str | Path,
+    *,
+    tile: int = 512,
+    pad: int = 64,
+    save_mask: bool = False,
+    device: str = "cpu",
+    max_pix_cpu: float = 7.0e7,
+) -> List[Path]:
+    """Write cloud-masked Sentinel-2 images.
+
+    Parameters
+    ----------
+    input
+        Path to a single ``.tif`` file **or** a directory containing them.
+    output
+        Destination directory (created if missing).
+    tile, pad
+        Tile size and padding (pixels) when tiling is required.
+    save_mask
+        If *True*, store the binary mask alongside the masked image.
+    device
+        Torch device for inference, e.g. ``"cpu"`` or ``"cuda:0"``.
+    max_pix_cpu
+        Tile images larger than this when running on CPU.
+
+    Returns
+    -------
+    list[pathlib.Path]
+        Paths to the generated masked images.
+    """
+    t_start = time.perf_counter()
+
+    src = Path(input).expanduser().resolve()
+    dst_dir = Path(output).expanduser().resolve()
+    dst_dir.mkdir(parents=True, exist_ok=True)
+
+    # Collect files to process -------------------------------------------------
+    tif_paths: list[Path]
+    if src.is_dir():
+        tif_paths = [p for p in src.rglob("*.tif")]
+    elif src.is_file() and src.suffix.lower() == ".tif":
+        tif_paths = [src]
+        src = src.parent  # for relative-path bookkeeping below
+    else:
+        raise ValueError(f"Input must be a .tif or directory, got: {src}")
+
+    if not tif_paths:
+        print(f"[cloud_masking] No .tif files found in {src}")
+        return []
+
+    experiment = mlstac.load("SEN2CloudEnsemble")
+    dm = DeviceManager(experiment, init_device=device)
+
+    masked_paths: list[Path] = []
+
+    # -------------------------------------------------------------------------
+    for idx, tif_path in enumerate(tif_paths, 1):
+        rel = tif_path.relative_to(src)
+        out_dir = dst_dir / rel.parent
+        out_dir.mkdir(parents=True, exist_ok=True)
+
+        mask_path = out_dir / f"{tif_path.stem}_cloudmask.tif"
+        masked_path = out_dir / f"{tif_path.stem}_masked.tif"
+
+        with rio.open(tif_path) as src_img:
+            profile = src_img.profile
+            h, w = src_img.height, src_img.width
+
+        mask_prof = profile.copy()
+        mask_prof.update(driver="GTiff", count=1, dtype="uint8", nodata=255)
+
+        do_tiling = (dm.device == "cuda") or (h * w > max_pix_cpu)
+        full_mask = np.full((h, w), 255, np.uint8)
+
+        t0 = time.perf_counter()
+
+        # ----------------------- inference -----------------------------------
+        if not do_tiling:  # full frame
+            with rio.open(tif_path) as src_img, torch.inference_mode():
+                img = src_img.read().astype(np.float32) / 1e4
+                h32, w32 = (h + 31) // 32 * 32, (w + 31) // 32 * 32
+                pad_b, pad_r = h32 - h, w32 - w
+                tensor = torch.from_numpy(img).unsqueeze(0)
+                if pad_b or pad_r:
+                    tensor = torch.nn.functional.pad(tensor, (0, pad_r, 0, pad_b))
+                mask = dm.model(tensor.to(dm.device)).squeeze(0)
+                full_mask[:] = mask[..., :h, :w].cpu().numpy().astype(np.uint8)
+        else:  # tiled
+            with rio.open(tif_path) as src_img, torch.inference_mode():
+                for y0 in range(0, h, tile):
+                    for x0 in range(0, w, tile):
+                        y0r, x0r = max(0, y0 - pad), max(0, x0 - pad)
+                        y1r, x1r = min(h, y0 + tile + pad), min(w, x0 + tile + pad)
+                        win = rio.windows.Window(x0r, y0r, x1r - x0r, y1r - y0r)
+
+                        patch = src_img.read(window=win).astype(np.float32) / 1e4
+                        tensor = torch.from_numpy(patch).unsqueeze(0).to(dm.device)
+                        mask = dm.model(tensor).squeeze(0).cpu().numpy().astype(np.uint8)
+
+                        y_in0 = pad if y0r else 0
+                        x_in0 = pad if x0r else 0
+                        y_in1 = mask.shape[0] - (pad if y1r < h else 0)
+                        x_in1 = mask.shape[1] - (pad if x1r < w else 0)
+                        core = mask[y_in0:y_in1, x_in0:x_in1]
+                        full_mask[y0 : y0 + core.shape[0], x0 : x0 + core.shape[1]] = core
+
+        # ----------------------- output --------------------------------------
+        if save_mask:
+            with rio.open(mask_path, "w", **mask_prof) as dst:
+                dst.write(full_mask, 1)
+
+        with rio.open(tif_path) as src_img:
+            data = src_img.read()
+            img_prof = src_img.profile.copy()
+
+        masked = data.copy()
+        masked[:, full_mask != 0] = 65535
+        img_prof.update(dtype="uint16", nodata=65535)
+
+        with rio.open(masked_path, "w", **img_prof) as dst:
+            dst.write(masked)
+
+        masked_paths.append(masked_path)
+        dt = time.perf_counter() - t0
+        print(f"[{idx}/{len(tif_paths)}] {rel} → done in {dt:.1f}s")
+
+    if dm.device == "cuda":
+        _reset_gpu()
+
+    total_time = time.perf_counter() - t_start
+    print(f"Processed {len(masked_paths)} image(s) in {total_time:.1f}s.")
+    return masked_paths

satcube-0.1.1/satcube/download.py

@@ -0,0 +1,65 @@
+import pathlib
+import ee
+import cubexpress
+import pandas as pd
+
+
+def download_data(
+    *,                     # keyword-only
+    lon: float,
+    lat: float,
+    cloud_max: int = 40,
+    edge_size: int = 2_048,
+    start: str,
+    end: str,
+    output: str = "raw",
+    scale: int = 10,
+    nworks: int = 4,
+    mosaic: bool = True,
+    auto_init_gee: bool = True,
+) -> pd.DataFrame:
+    """
+    Download a Sentinel cube for (lon, lat) and return its metadata.
+
+    Parameters
+    ----------
+    lon, lat        Center point in degrees.
+    cloud_max       Max cloud cover (%).
+    edge_size       Square side length (m).
+    start, end      YYYY-MM-DD date range.
+    output          Folder for GeoTIFFs.
+    scale           Pixel size (m).
+    nworks          Parallel workers.
+    mosaic          Merge scenes per date.
+    auto_init_gee   Call ee.Initialize() if needed.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Scene catalogue used for the request.
+    """
+    # EE ready
+    if auto_init_gee:
+        try:
+            ee.Initialize()
+        except ee.EEException:
+            ee.Authenticate(); ee.Initialize()
+
+    # Filter scenes
+    df = cubexpress.cloud_table(
+        lon=lon,
+        lat=lat,
+        edge_size=edge_size,
+        scale=scale,
+        cloud_max=cloud_max,
+        start=start,
+        end=end,
+    )
+
+    # Build requests + ensure dir
+    requests = cubexpress.table_to_requestset(df, mosaic=mosaic)
+    pathlib.Path(output).mkdir(parents=True, exist_ok=True)
+
+    # Download cube
+    cubexpress.get_cube(requests, output, nworks)
+    return df

satcube-0.1.1/satcube/download_old.py

@@ -0,0 +1,82 @@
+import ee
+import cubexpress
+import pathlib
+from typing import Optional
+from datetime import datetime
+
+def download_data(
+    lon: float,
+    lat: float,
+    cs_cdf: Optional[float] = 0.6,
+    buffer_size: Optional[int] = 1280,
+    start_date: Optional[str] = "2015-01-01",
+    end_date: Optional[str] = datetime.today().strftime('%Y-%m-%d'),
+    outfolder: Optional[str] = "raw/"
+) -> pathlib.Path:
+    """
+    Download Sentinel-2 imagery data using cubexpress and Earth Engine API.
+
+    Args:
+        lon (float): Longitude of the point of interest.
+        lat (float): Latitude of the point of interest.
+        cs_cdf (Optional[float]): Cloud mask threshold (default 0.6).
+        buffer_size (Optional[int]): Buffer size for image extraction (default 1280).
+        start_date (Optional[str]): Start date for image filtering (default "2015-01-01").
+        end_date (Optional[str]): End date for image filtering (default today’s date).
+        outfolder (Optional[str]): Output folder to save images (default "raw/").
+
+    Returns:
+        pathlib.Path: Path to the folder where the data is stored.
+    """
+    
+    # Initialize Earth Engine
+    ee.Initialize(project="ee-julius013199")
+
+    # Define point of interest
+    point = ee.Geometry.Point([lon, lat])
+    
+    # Filter image collection by location and date
+    collection = ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED") \
+                    .filterBounds(point) \
+                    .filterDate(start_date, end_date)
+
+    # Get image IDs
+    image_ids = collection.aggregate_array('system:id').getInfo()
+    
+    # Cloud mask function
+    def cloud_mask(image) -> ee.Image:
+        """Apply cloud mask to the image."""
+        return image.select('MSK_CLDPRB').lt(20)
+
+    # Apply cloud mask
+    collection = collection.map(cloud_mask)
+    
+    # Generate geotransform for cubexpress
+    geotransform = cubexpress.lonlat2rt(lon=lon, lat=lat, edge_size=buffer_size, scale=10)
+
+    # Prepare requests for cubexpress
+    requests = [
+        cubexpress.Request(
+            id=f"s2test_{i}",
+            raster_transform=geotransform,
+            bands=["B4", "B3", "B2"],  # RGB bands
+            image=ee.Image(image_id).divide(10000)  # Adjust image scaling
+        )
+        for i, image_id in enumerate(image_ids)
+    ]
+    
+    # Create request set
+    cube_requests = cubexpress.RequestSet(requestset=requests)
+
+    # Set output folder
+    output_path = pathlib.Path(outfolder)
+
+    # Download the data
+    cubexpress.getcube(
+        request=cube_requests,
+        output_path=output_path,
+        nworkers=4,
+        max_deep_level=5
+    )
+    
+    return output_path

{satcube-0.1.0 → satcube-0.1.1}/satcube/main.py

@@ -7,7 +7,7 @@ import pandas as pd
 import torch
 
 from satcube.dataclass import Sensor
-from satcube.utils import (aligned_s2, cloudmasking_s2, display_images,
+from satcube.utils_old import (aligned_s2, cloudmasking_s2, display_images,
                            gapfilling_s2, intermediate_process, interpolate_s2,
                            metadata_s2, monthly_composites_s2, smooth_s2, super_s2)
 
@@ -252,7 +252,7 @@ class SatCube:
         out_table["folder"] = out_folder
 
         return out_table
-
+    
     def monthly_composites_s2(
         self,
         table: Optional[pd.DataFrame],

satcube-0.1.1/satcube/utils.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import gc
+from typing import Any, Optional
+
+import torch
+
+
+def _reset_gpu() -> None:
+    """Release CUDA memory and reset allocation statistics.
+
+    Calling this on a system without a CUDA device is a no-op.
+    """
+    torch.cuda.empty_cache()
+    torch.cuda.reset_peak_memory_stats()
+
+
+class DeviceManager:
+    """Hold a compiled mlstac model and move it between devices on demand."""
+
+    def __init__(self, experiment: Any, init_device: str = "cpu") -> None:
+        """
+        Parameters
+        ----------
+        experiment
+            An mlstac experiment exposing ``compiled_model``.
+        init_device
+            Device where the model is first compiled, e.g. ``"cpu"`` or
+            ``"cuda:0"``.
+        """
+        self._experiment: Any = experiment
+        self.device: Optional[str] = None
+        self.model: Optional[torch.nn.Module] = None
+        self.switch(init_device)
+
+    def switch(self, new_device: str) -> torch.nn.Module:
+        """Return a model compiled for *new_device*, recompiling if needed.
+
+        Parameters
+        ----------
+        new_device
+            Target device identifier.
+
+        Returns
+        -------
+        torch.nn.Module
+            The model resident on *new_device*.
+
+        Raises
+        ------
+        AssertionError
+            If *new_device* requests CUDA but no GPU is available.
+        """
+        if new_device == self.device:
+            return self.model  # type: ignore[return-value]
+
+        if self.model is not None:
+            del self.model
+        gc.collect()
+
+        if self.device == "cuda":
+            _reset_gpu()
+
+        if new_device == "cuda":
+            assert torch.cuda.is_available(), "CUDA device not detected"
+
+        print(f"→ Compiling model on {new_device} …")
+        self.model = self._experiment.compiled_model(device=new_device, mode="max")
+        self.device = new_device
+        return self.model

satcube-0.1.0/PKG-INFO

@@ -1,31 +0,0 @@
-Metadata-Version: 2.1
-Name: satcube
-Version: 0.1.0
-Summary: A Python package to create cloud-free monthly composites by fusing Landsat and Sentinel-2 data.
-Home-page: https://github.com/IPL-UV/satcube
-Author: Cesar Aybar
-Author-email: fcesar.aybar@uv.es
-Requires-Python: >=3.10,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Requires-Dist: earthengine-api (>=0.1.4.0)
-Requires-Dist: fastcubo (>=0.0.999)
-Requires-Dist: matplotlib (>=3.7.0)
-Requires-Dist: numpy (>=1.25.0)
-Requires-Dist: pandas (>=2.0.0)
-Requires-Dist: phicloudmask (>=0.0.2)
-Requires-Dist: pydantic (>=2.8.0)
-Requires-Dist: rasterio (>=1.2.0)
-Requires-Dist: requests (>=2.26.0)
-Requires-Dist: satalign (>=0.0.999)
-Requires-Dist: scikit-learn (>=1.2.0)
-Requires-Dist: segmentation-models-pytorch (>=0.2.0)
-Requires-Dist: torch (>=2.0.0)
-Requires-Dist: xarray (>=2023.7.0)
-Project-URL: Documentation, https://ipl-uv.github.io/satcube/
-Project-URL: Repository, https://github.com/IPL-UV/satcube
-Description-Content-Type: text/markdown
-
-# satcube
-
-[colab code](https://colab.research.google.com/drive/1)

satcube-0.1.0/README.md

@@ -1,3 +0,0 @@
-# satcube
-
-[colab code](https://colab.research.google.com/drive/1)

satcube-0.1.0/pyproject.toml

@@ -1,116 +0,0 @@
-[tool.poetry]
-name = "satcube"
-version = "0.1.0"
-description = "A Python package to create cloud-free monthly composites by fusing Landsat and Sentinel-2 data."
-authors = ["Cesar Aybar <fcesar.aybar@uv.es>"]
-repository = "https://github.com/IPL-UV/satcube"
-documentation = "https://ipl-uv.github.io/satcube/"
-readme = "README.md"
-packages = [
-  {include = "satcube"}
-]
-
-[tool.poetry.dependencies]
-python = ">=3.10,<4.0"
-fastcubo = ">=0.0.999"
-torch = ">=2.0.0"
-pandas = ">=2.0.0"
-pydantic = ">=2.8.0"
-earthengine-api = ">=0.1.4.0"
-matplotlib = ">=3.7.0"
-numpy = ">=1.25.0"
-phicloudmask = ">=0.0.2"
-rasterio = ">=1.2.0"
-requests = ">=2.26.0"
-satalign = ">=0.0.999"
-scikit-learn = ">=1.2.0"
-segmentation-models-pytorch = ">=0.2.0"
-xarray = ">=2023.7.0"
-
-
-[tool.poetry.group.dev.dependencies]
-pytest = "^7.2.0"
-pytest-cov = "^4.0.0"
-deptry = "^0.12.0"
-mypy = "^1.5.1"
-pre-commit = "^3.4.0"
-tox = "^4.11.1"
-
-[tool.poetry.group.docs.dependencies]
-mkdocs = "^1.4.2"
-mkdocs-material = "^9.2.7"
-mkdocstrings = {extras = ["python"], version = "^0.23.0"}
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.mypy]
-files = ["satcube"]
-disallow_untyped_defs = "True"
-disallow_any_unimported = "True"
-no_implicit_optional = "True"
-check_untyped_defs = "True"
-warn_return_any = "True"
-warn_unused_ignores = "True"
-show_error_codes = "True"
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-
-[tool.ruff]
-target-version = "py37"
-line-length = 120
-fix = true
-select = [
-    # flake8-2020
-    "YTT",
-    # flake8-bandit
-    "S",
-    # flake8-bugbear
-    "B",
-    # flake8-builtins
-    "A",
-    # flake8-comprehensions
-    "C4",
-    # flake8-debugger
-    "T10",
-    # flake8-simplify
-    "SIM",
-    # isort
-    "I",
-    # mccabe
-    "C90",
-    # pycodestyle
-    "E", "W",
-    # pyflakes
-    "F",
-    # pygrep-hooks
-    "PGH",
-    # pyupgrade
-    "UP",
-    # ruff
-    "RUF",
-    # tryceratops
-    "TRY",
-]
-ignore = [
-    # LineTooLong
-    "E501",
-    # DoNotAssignLambda
-    "E731",
-]
-
-[tool.ruff.format]
-preview = true
-
-[tool.coverage.report]
-skip_empty = true
-
-[tool.coverage.run]
-branch = true
-source = ["satcube"]
-
-
-[tool.ruff.per-file-ignores]
-"tests/*" = ["S101"]

satcube-0.1.0/satcube/__init__.py

@@ -1,3 +0,0 @@
-from satcube.dataclass import Sentinel2
-from satcube.main import SatCube
-from satcube.utils import download_weights, monthly_calendar

satcube-0.1.0/setup.py

@@ -1,43 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['satcube']
-
-package_data = \
-{'': ['*']}
-
-install_requires = \
-['earthengine-api>=0.1.4.0',
- 'fastcubo>=0.0.999',
- 'matplotlib>=3.7.0',
- 'numpy>=1.25.0',
- 'pandas>=2.0.0',
- 'phicloudmask>=0.0.2',
- 'pydantic>=2.8.0',
- 'rasterio>=1.2.0',
- 'requests>=2.26.0',
- 'satalign>=0.0.999',
- 'scikit-learn>=1.2.0',
- 'segmentation-models-pytorch>=0.2.0',
- 'torch>=2.0.0',
- 'xarray>=2023.7.0']
-
-setup_kwargs = {
-    'name': 'satcube',
-    'version': '0.1.0',
-    'description': 'A Python package to create cloud-free monthly composites by fusing Landsat and Sentinel-2 data.',
-    'long_description': '# satcube\n\n[colab code](https://colab.research.google.com/drive/1)',
-    'author': 'Cesar Aybar',
-    'author_email': 'fcesar.aybar@uv.es',
-    'maintainer': 'None',
-    'maintainer_email': 'None',
-    'url': 'https://github.com/IPL-UV/satcube',
-    'packages': packages,
-    'package_data': package_data,
-    'install_requires': install_requires,
-    'python_requires': '>=3.10,<4.0',
-}
-
-
-setup(**setup_kwargs)