SnowMapPy 1.0.1__py3-none-any.whl

local/preparator.py

@@ -0,0 +1,146 @@
+import os
+import rasterio
+import datetime
+import numpy as np
+import xarray as xr
+from tqdm import tqdm
+from rasterio.features import geometry_mask
+from rasterio.mask import mask as rasterio_mask
+
+from ..core.spatial import clip_dem_to_roi, check_overlap, reproject_shp, handle_reprojection
+from ..core.data_io import save_as_zarr, load_shapefile
+
+
+def prepare_modis(data_dir, save_dir, dem_path, shp_path, oparams_file=None,
+                  priority='MODIS', save_name='MODIS', save_dem=True, dem_name='DEM'):
+    """
+    Prepare MODIS data for processing.
+    """
+    # Load the ROI shapefile
+    roi = load_shapefile(shp_path)
+    
+    # Ensure output directories exist
+    os.chdir(data_dir)
+    subdirs = os.listdir(data_dir)
+    
+    modis_save_dir = os.path.join(save_dir, save_name)
+    if not os.path.exists(modis_save_dir):
+        os.makedirs(modis_save_dir)
+    if save_dem:
+        dem_save_dir = os.path.join(save_dir, 'DEM')
+        if not os.path.exists(dem_save_dir):
+            os.makedirs(dem_save_dir)
+    
+    # Open DEM once to extract its CRS
+    with rasterio.open(dem_path) as dem_src:
+        dem_crs = dem_src.crs
+
+    # Prepare lists to accumulate the processed MODIS arrays and their dates.
+    modis_data_list = []
+    time_list = []
+    lat = None
+    lon = None
+    first_valid = True  # flag for first successful processing
+
+    # Process each directory
+    for k in tqdm(range(len(subdirs)), desc="Processing directories"):
+        currD = os.path.join(data_dir, subdirs[k])
+        files = os.listdir(currD)
+        os.chdir(currD)
+        
+        # Look for a Snow Cover file ending with '.tif'
+        scfile = [f for f in files if 'Snow_Cover' in f and f.endswith('.tif')]
+        if not scfile:
+            tqdm.write(f'No Snow Cover data found in {currD}.')
+            continue
+        
+        fname = scfile[0]
+        DateSve = datetime.datetime.strptime(fname[9:16], '%Y%j').strftime('%Y-%m-%d')
+        img_path = os.path.join(currD, scfile[0])
+        
+        with rasterio.open(img_path) as src:
+            # Check if the CRS of the MODIS image and the DEM are the same
+            if src.crs != dem_crs:
+                if priority == 'MODIS' and k == 0:
+                    # Reproject DEM to match MODIS CRS
+                    dem_file = os.path.basename(dem_path)
+                    if save_dem:
+                        reprojected_dem = os.path.join(dem_path, f"reprojected_{dem_file}")
+                    else:
+                        reprojected_dem = os.path.join(os.path.dirname(dem_path), f"reprojected_{dem_file}")
+                    handle_reprojection(img_path, dem_path, reprojected_dem, priority=priority)
+                    dem_path = reprojected_dem
+                    with rasterio.open(dem_path) as new_dem:
+                        dem_crs = new_dem.crs
+                elif priority == 'DEM':
+                    # Reproject the MODIS image to match the DEM CRS
+                    reprojected_image = os.path.join(currD, f"reprojected_{scfile[0]}")
+                    handle_reprojection(img_path, dem_path, reprojected_image, priority=priority)
+                    img_path = reprojected_image
+                    # Re-open the reprojected image to use its CRS
+                    src = rasterio.open(img_path)
+            
+            # On the first valid image, reproject the ROI to the MODIS image's CRS
+            if first_valid:
+                reprojected_roi = reproject_shp(roi, src.crs)
+                first_valid = False
+            
+            if not check_overlap(src, reprojected_roi):
+                tqdm.write(f"ROI does not overlap with raster in {currD}. Skipping...")
+                continue
+
+            try:
+                # Mask the raster using the ROI geometry
+                SCA, out_transf = rasterio_mask(src, [reprojected_roi.geometry.iloc[0]],
+                                                crop=True, all_touched=True, pad=True)
+                SCA = SCA[0]  # remove the band dimension
+            except ValueError as e:
+                tqdm.write(f"Masking failed in {currD}: {e}")
+                continue
+        
+        # Create the ROI mask and coordinate grid only once (assuming same shape across images)
+        if lat is None or lon is None:
+            ROI_mask = geometry_mask(reprojected_roi.geometry,
+                                    transform=out_transf,
+                                    invert=True,
+                                    out_shape=SCA.shape)
+            ROI_mask = np.where(ROI_mask == 0, np.nan, 1)
+            
+            bounds = rasterio.transform.array_bounds(SCA.shape[0], SCA.shape[1], out_transf)
+            X, Y = np.meshgrid(np.linspace(bounds[0], bounds[2], SCA.shape[1]),
+                               np.linspace(bounds[3], bounds[1], SCA.shape[0]))
+            lat = Y[:, 0].tolist()
+            lon = X[0, :].tolist()
+        
+        # Apply the ROI mask to the clipped data
+        SCA_ROI = SCA * ROI_mask
+        
+        # Store the processed data and date
+        modis_data_list.append(SCA_ROI)
+        time_list.append(DateSve)
+    
+    # Create the final dataset
+    if modis_data_list:
+        modis_array = np.stack(modis_data_list, axis=0)
+        
+        ds = xr.Dataset(
+            data_vars={
+                'NDSI': (('time', 'lat', 'lon'), modis_array)
+            },
+            coords={
+                'time': time_list,
+                'lat': lat,
+                'lon': lon
+            }
+        )
+        
+        # Save the dataset
+        save_as_zarr(ds, modis_save_dir, 'MODIS', oparams_file)
+        
+        # Save DEM if requested
+        if save_dem:
+            clip_dem_to_roi(dem_path, roi, dem_save_dir, dem_name, oparams_file)
+        
+        return ds
+    else:
+        raise ValueError("No valid MODIS data found in the specified directory.") 

local/processor.py

@@ -0,0 +1,141 @@
+import os
+import sys
+import datetime
+import numpy as np
+import pandas as pd
+import xarray as xr
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+from ..core.temporal import vectorized_interpolation_griddata_parallel
+from ..core.data_io import save_as_zarr, load_dem_and_nanmask, load_shapefile
+from ..core.utils import generate_time_series
+
+
+def load_or_create_nan_array(dataset, date, shape, var_name):
+    """
+    Return data or a nan array.
+    """
+    # Convert date to string
+    date = date.strftime('%Y-%m-%d')
+    if date in dataset.time.values:
+        return dataset.sel(time=date)[var_name].values
+    else:
+        return np.full(shape, np.nan)
+
+
+def process_files_array(series, movwind, currentday_ind, mod_data, myd_data,
+                          dem, nanmask, daysbefore, daysafter, var_name):
+    """
+    Process the time series and accumulate processed images into a single array.
+    """
+    mod_arr = mod_data[var_name].values
+    lat_dim, lon_dim, _ = mod_arr.shape
+    n_processed = len(series) - daysbefore - daysafter
+    out_arr = np.empty((lat_dim, lon_dim, n_processed), dtype=np.float64)
+    out_dates = []
+
+    for i in tqdm(range(daysbefore, len(series) - daysafter), desc="Processing Files"):
+        
+        if i == daysbefore:
+            # Extract the moving window with specific days
+            window_mod = np.array([load_or_create_nan_array(mod_data, series[i + j], (lat_dim, lon_dim), var_name) for j in movwind])
+            window_myd = np.array([load_or_create_nan_array(myd_data, series[i + j], (lat_dim, lon_dim), var_name) for j in movwind])
+
+            # Move the time dimension to the last axis
+            window_mod = np.moveaxis(window_mod, 0, -1)
+            window_myd = np.moveaxis(window_myd, 0, -1)
+        else:
+            window_mod = np.roll(window_mod, -1, axis=2)
+            window_myd = np.roll(window_myd, -1, axis=2)
+            # Printing shape after rolling
+
+            window_mod[:, :, -1] = np.array(load_or_create_nan_array(mod_data, series[i + daysafter], (lat_dim, lon_dim), var_name))
+            window_myd[:, :, -1] = np.array(load_or_create_nan_array(myd_data, series[i + daysafter], (lat_dim, lon_dim), var_name))
+
+        # Apply the DEM nanmask
+        window_mod[nanmask, :] = np.nan
+        window_myd[nanmask, :] = np.nan
+
+        # Merge Aqua and Terra based on quality codes
+        codvals = [200, 201, 211, 237, 239, 250, 254, 255]
+        MODind = np.isin(window_mod, codvals)
+        MYDind = np.isin(window_myd, codvals)
+        MERGEind = (MODind == 1) & (MYDind == 0)
+        NDSIFill_MERGE = np.where(MERGEind, window_myd, window_mod)
+
+        # Select the current day slice from the moving window
+        NDSI_merge = np.squeeze(NDSIFill_MERGE[:, :, currentday_ind])
+
+        # Quality control adjustment based on DEM values and code distribution
+        cond1 = np.float64(dem > 1000)
+        cond2 = np.float64((dem > 1000) & np.isin(NDSI_merge, codvals))
+        if (np.sum(cond2) / np.sum(cond1)) < 0.60:
+            sc = (NDSI_merge == 100)
+            meanZ = np.mean(dem[sc])
+            if np.sum(sc) > 10:
+                ind = (dem > meanZ) & np.isin(NDSI_merge, codvals)
+                NDSI_merge[ind] = 100
+                print('I did it')
+
+        # Clean up values and perform spatial interpolation on missing data
+        NDSIFill_MERGE[NDSIFill_MERGE > 100] = np.nan
+        NDSIFill_MERGE = vectorized_interpolation_griddata_parallel(NDSIFill_MERGE, nanmask)
+        NDSIFill_MERGE = np.clip(NDSIFill_MERGE, 0, 100)
+
+        NDSI = np.squeeze(NDSIFill_MERGE[:, :, currentday_ind])
+        dem_ind = dem < 1000
+        NDSI[dem_ind] = 0
+
+        # Accumulate the processed image and record the date label
+        out_arr[:, :, i - daysbefore] = NDSI
+        # out_dates.append(series[i].strftime('%Y-%m-%d'))
+        out_dates.append(series[i])
+
+    return out_arr, out_dates
+
+
+def modis_time_series(mod_ds, myd_ds, dem_ds, output_zarr, file_name, var_name='NDSI', oparams_file=None):
+    """
+    Main function to run the processing and save all images in a single zarr dataset.
+    """
+    daysbefore = 3
+    daysafter = 2
+
+    # Load DEM and create nanmask
+    dem, nanmask = load_dem_and_nanmask(dem_ds)
+
+    # Verify that both datasets contain the variable 'NDSI'
+    if var_name not in mod_ds or var_name not in myd_ds:
+        raise ValueError("One of the datasets does not contain the 'NDSI' variable.")
+
+    # Get the full timeseries arrays; expected shape is (lat, lon, time)
+    mod_data = mod_ds[var_name].values
+    myd_data = myd_ds[var_name].values
+
+    # Check that spatial dimensions match between Terra and Aqua data
+    if mod_data.shape[:2] != myd_data.shape[:2]:
+        raise ValueError("Terra and Aqua data do not have matching spatial dimensions.")
+
+    # Generate a continuous daily time series and moving window parameters
+    series, movwind, currentday_ind, _ = generate_time_series(mod_ds['time'].values, daysbefore, daysafter)
+
+    # Process and accumulate all processed images
+    out_arr, out_dates = process_files_array(series, movwind, currentday_ind, mod_ds, myd_ds,
+                                               dem, nanmask, daysbefore, daysafter, var_name)
+
+    # Create an xarray Dataset to store the complete time series in a single zarr file
+    ds_out = xr.Dataset(
+        {
+            var_name: (("lat", "lon", "time"), out_arr)
+        },
+        coords={
+            "lat": mod_ds["lat"],
+            "lon": mod_ds["lon"],
+            "time": out_dates
+        }
+    )
+    
+    # Save the dataset to a single zarr store
+    save_as_zarr(ds_out, output_zarr, file_name, params_file=oparams_file)
+
+    return ds_out 

snowmappy-1.0.1.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.4
+Name: SnowMapPy
+Version: 1.0.1
+Summary: A comprehensive Python package for processing MODIS NDSI data from local files and Google Earth Engine
+Home-page: https://github.com/Hbechri/SnowMapPy
+Author: Haytam Elyoussfi
+Author-email: haytam.elyoussfi@um6p.ma
+Project-URL: Bug Reports, https://github.com/Hbechri/SnowMapPy/issues
+Project-URL: Source, https://github.com/Hbechri/SnowMapPy
+Project-URL: Documentation, https://github.com/Hbechri/SnowMapPy#readme
+Keywords: modis,snow,remote sensing,earth engine,gis,hydrology
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy==2.1.0
+Requires-Dist: scipy==1.15.2
+Requires-Dist: pandas==2.2.3
+Requires-Dist: rasterio==1.4.3
+Requires-Dist: geopandas==1.0.1
+Requires-Dist: pyproj==3.7.1
+Requires-Dist: shapely==2.1.0
+Requires-Dist: affine==2.4.0
+Requires-Dist: xarray==2025.3.1
+Requires-Dist: zarr==3.0.6
+Requires-Dist: numcodecs==0.16.0
+Requires-Dist: h5py==3.13.0
+Requires-Dist: netCDF4==1.7.2
+Requires-Dist: earthengine-api==1.5.9
+Requires-Dist: geemap==0.35.3
+Requires-Dist: tqdm==4.66.4
+Requires-Dist: joblib==1.4.2
+Requires-Dist: python-dateutil==2.9.0
+Requires-Dist: matplotlib==3.10.1
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: flake8>=3.8; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# SnowMapPy 🌨️
+
+A comprehensive Python package for processing MODIS NDSI (Normalized Difference Snow Index) data from both local files and Google Earth Engine, with advanced quality control and temporal interpolation capabilities.
+
+## 📋 Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Package Structure](#package-structure)
+- [Usage Examples](#usage-examples)
+- [Testing](#testing)
+- [Contributing](#contributing)
+- [License](#license)
+
+## ✨ Features
+
+- **🌐 Cloud Processing**: Download and process MODIS NDSI data directly from Google Earth Engine
+- **💾 Local Processing**: Process locally stored MODIS NDSI files
+- **🔍 Quality Control**: Advanced masking using NDSI_Snow_Cover_Class for data validation
+- **⏰ Temporal Interpolation**: Fill missing data points using spatial and temporal interpolation
+- **🗺️ Spatial Operations**: Clip data to regions of interest using shapefiles or bounding boxes
+- **📊 Data Export**: Save processed data in Zarr format for efficient storage and access
+- **🧪 Comprehensive Testing**: Unit tests and real-world processing tests
+
+## 🚀 Installation
+
+### Option 1: Install from PyPI (Recommended)
+
+```bash
+pip install SnowMapPy
+```
+
+### Option 2: Install from GitHub
+
+1. **Clone the repository:**
+   ```bash
+   git clone https://github.com/Hbechri/SnowMapPy.git
+   cd SnowMapPy/package
+   ```
+
+2. **Install the package:**
+   ```bash
+   pip install -e .
+   ```
+
+### Prerequisites
+
+- Python 3.8+
+- Google Earth Engine account (for cloud processing)
+- Required Python packages (automatically installed with the package)
+
+### Google Earth Engine Setup (for cloud processing)
+
+1. **Sign up for Google Earth Engine:**
+   - Visit [https://earthengine.google.com/](https://earthengine.google.com/)
+   - Sign up for an account
+
+2. **Authenticate:**
+   ```bash
+   earthengine authenticate
+   ```
+
+## 🎯 Quick Start
+
+### Cloud Processing Example
+
+```python
+from SnowMapPy.cloud.processor import process_modis_ndsi_cloud
+
+# Process MODIS NDSI data from Google Earth Engine
+result = process_modis_ndsi_cloud(
+    project_name="your-gee-project",
+    shapefile_path="path/to/roi.shp",
+    start_date="2023-01-01",
+    end_date="2023-01-31",
+    output_path="output/",
+    file_name="snow_cover"
+)
+```
+
+### Local Processing Example
+
+```python
+from SnowMapPy.local.processor import process_modis_ndsi_local
+
+# Process locally stored MODIS NDSI files
+result = process_modis_ndsi_local(
+    mod_dir="path/to/MOD/files/",
+    myd_dir="path/to/MYD/files/",
+    dem_file="path/to/dem.tif",
+    output_path="output/",
+    file_name="local_snow_cover"
+)
+```
+
+## 📁 Package Structure
+
+```
+SnowMapPy/
+├── core/                    # Shared functionality
+│   ├── data_io.py          # Data input/output operations
+│   ├── quality.py           # Quality control functions
+│   ├── spatial.py           # Spatial operations
+│   ├── temporal.py          # Temporal interpolation
+│   └── utils.py             # Utility functions
+├── cloud/                   # Google Earth Engine processing
+│   ├── auth.py              # GEE authentication
+│   ├── loader.py            # Data loading from GEE
+│   └── processor.py         # Cloud processing pipeline
+├── local/                   # Local file processing
+│   ├── file_handler.py      # File management
+│   ├── preparator.py        # Data preparation
+│   └── processor.py         # Local processing pipeline
+└── tests/                   # Test suite
+    ├── test_core/           # Core functionality tests
+    ├── test_cloud/          # Cloud processing tests
+    └── test_local/          # Local processing tests
+```
+
+## 📖 Usage Examples
+
+### Quality Control
+
+```python
+from SnowMapPy.core.quality import get_invalid_modis_classes, apply_modis_quality_mask
+
+# Get invalid MODIS class values
+invalid_classes = get_invalid_modis_classes()
+print(f"Invalid classes: {invalid_classes}")
+
+# Apply quality mask to data
+masked_data = apply_modis_quality_mask(value_data, class_data)
+```
+
+### Spatial Operations
+
+```python
+from SnowMapPy.core.spatial import clip_dem_to_roi
+
+# Clip DEM to region of interest
+clipped_dem = clip_dem_to_roi(dem_data, shapefile_path)
+```
+
+## 🧪 Testing
+
+Run the test suite:
+
+```bash
+# Run all tests
+python -m pytest tests/
+
+# Run specific test categories
+python tests/test_core/test_quality.py
+python tests/test_cloud/test_basic_cloud.py
+```
+
+For detailed testing instructions, see [TESTING.md](TESTING.md).
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Google Earth Engine team for providing the platform
+- NASA for MODIS data
+- The open-source geospatial community
+
+## 📞 Support
+
+- **Issues**: [GitHub Issues](https://github.com/Hbechri/SnowMapPy/issues)
+- **Documentation**: [GitHub README](https://github.com/Hbechri/SnowMapPy#readme)
+- **Email**: haytam.elyoussfi@um6p.ma

snowmappy-1.0.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+cloud/__init__.py,sha256=-R4cEQvkGtzIr5kE3C8Ul0I3KDg3uYaXDqtSUaYxyQw,353
+cloud/auth.py,sha256=Yu_QtIiWiJ9x5omyah6P4qdocVSIKaOiyoUNH517Ssc,607
+cloud/loader.py,sha256=KOkJYAp8-wSRLLkcsrQEM_rFCD_cquHLOVZ_8lNoip4,4172
+cloud/processor.py,sha256=bUWMxkDeY-ldpXTmdPbveglgttXGmpfgjYFVah26F54,19063
+core/__init__.py,sha256=zsLmlyo72uNvLJIwlgjccMiNmddug8DFihdSE8TnUVU,949
+core/data_io.py,sha256=cHnjnbbkhqXPWKLXY867Mz22g7NFsoQnDq8edoE-f_Q,6137
+core/quality.py,sha256=ARxwQG7fcj0CXrSlScd1s3OiS-ivHYRef_LbN23o64I,4766
+core/spatial.py,sha256=HEBmgO9j6Nd9Lr1FPnyTZBVJOPyXm8oBBcj_2y6Olj4,4412
+core/temporal.py,sha256=2FGLYw94iNu4yXBFrpEAy74XlEFWw9Oxh68_RMY46Cs,1387
+core/utils.py,sha256=WlJ6BFN7XqX2s9lWRe8iENqAaUwtqzVZnRtSt_RFNyg,1632
+local/__init__.py,sha256=S6IVb8aFMuNS_sm4isnV4rti2Nvzt11aTJ0V7ZG4IT8,352
+local/file_handler.py,sha256=bLlILjMRLq8yuABzNaDb8SuR0zSXSe5lTQhVnxrdnek,1232
+local/preparator.py,sha256=6dBTmSsGhzEOCvg_cqDHa6YUJdnD8iOQchltwSCoSQI,6005
+local/processor.py,sha256=j360BWyggbog_ccCsOMOtRZ2iDZJjUvWJc2ZlNp64n0,5820
+tests/__init__.py,sha256=5wfjsghwLVndZWJQRfB7KWeY62bssenUWW9MV81s7Po,35
+tests/test_cloud/__init__.py,sha256=UXkfFwW1CGgXacpI90nnP59d5VIZ4U9LhD8Vvtzlxz4,21
+tests/test_cloud/real_cloud_test.py,sha256=m2BPKHtgD-nAhp8Tg5BnidTMkFL7CW7YfKpthCD7t-s,14760
+tests/test_cloud/test_basic_cloud.py,sha256=Od-svnU1_CAJWL80GLhDGzIq2YaNyBtmelbJBPVruzs,8349
+tests/test_core/__init__.py,sha256=0bvz0rqDybg2L5J3jXJF2RBF8E51vXhTxbQGCUG4TZ8,20
+tests/test_core/test_quality.py,sha256=nefFrWzX7zNclQZCGbd85obpAj83a4tKjDY2LWKWjtk,2355
+tests/test_local/__init__.py,sha256=85fWbznBK4B08nWGMFcMC-fe4SrWa6ZKwMTQWrAUjRk,21
+snowmappy-1.0.1.dist-info/METADATA,sha256=OZ5axg2d2Oqw5bsorai-a0OxstKNSse36GWyDGYiTrA,7745
+snowmappy-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+snowmappy-1.0.1.dist-info/top_level.txt,sha256=x0dVy4Hq9VmXJnj_f5EJ6YjdO5tdueEuynPmZiBvMTQ,23
+snowmappy-1.0.1.dist-info/RECORD,,

snowmappy-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

snowmappy-1.0.1.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+cloud
+core
+local
+tests

tests/__init__.py

@@ -0,0 +1 @@
+# Test suite for SnowMapPy package 

tests/test_cloud/__init__.py

@@ -0,0 +1 @@
+# Cloud module tests