ecoenv 0.1.0__tar.gz

ecoenv-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 EcoToolBox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ecoenv-0.1.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: ecoenv
+Version: 0.1.0
+Summary: A Python library for ecological data collection and environmental analysis
+Author: Ane Simões
+Author-email: anes.2017@alunos.utfpr.edu.br
+License: MIT
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ee
+Requires-Dist: pandas
+Requires-Dist: requests
+Requires-Dist: python-dotenv
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# USAGE.md
+
+## Overview
+
+**ecoenv** is a library designed to facilitate data management and processing for scientific and research applications.
+
+## Getting Started
+
+### Installation
+
+```bash
+pip install ecoenv
+```
+
+### Basic Usage
+
+```python
+import ecoenv
+
+
+ecoenv.autenticateEE('project_name')
+ecoenv.get_environment_data(gdf, ndvi=True, ndwi=True, temperature=True, precipitation=True)
+```
+## Functions
+- `autenticateEE`: Authenticates the user with the Earth Engine API using the specified project name.
+- `get_environment_data`: Retrieves environmental data based on the provided geospatial data frame (gdf) and specified parameters (ndvi, ndwi, temperature, precipitation).
+

ecoenv-0.1.0/README.md

@@ -0,0 +1,48 @@
+
+# EcoEnv
+
+## Overview
+
+EcoEnv is a project focused on environmental monitoring and ecological analysis. This repository contains tools and utilities for tracking environmental metrics and managing ecosystem data.
+
+## Features
+
+- Environmental data collection
+- Ecological metrics analysis
+- Data visualization
+- Real-time monitoring
+
+## Getting Started
+
+### Prerequisites
+
+- Python 3.8+
+- pip or conda
+
+### Installation
+
+```bash
+git clone https://github.com/EcoToolBox/EcoEnv.git
+cd EcoEnv
+pip install -r requirements.txt
+```
+
+### Usage
+
+```python
+import ecoenk
+
+# Your code here
+```
+
+## Contributing
+
+Contributions are welcome! Please fork the repository and submit a pull request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Support
+
+For issues and questions, please open an issue on GitHub.

ecoenv-0.1.0/ecoenv/__init__.py

@@ -0,0 +1,21 @@
+from .env_request import get_environment_data, autenticateEE
+# from .gbif import save_gbif_credentials, delete_gbif_credentials, get_species_autocomplete
+# from .speciesLink import save_specieslink_apikey, delete_specieslink_apikey
+
+__all__ = [
+    "get_environment_data",
+    "autenticateEE"
+]
+
+def version():
+    return "0.0.1"
+def  describe ():   
+    description = ( 
+        "Eco Env Library\n" 
+        "Version: {}\n" 
+        "Implement functions to get environment data from GEE and (soon) GlobalBioticInteractions as:\n" 
+        " - get_environment_data\n" 
+        " - autenticateEE\n" 
+     ). format (version()) 
+    print (description) 
+    return description

ecoenv-0.1.0/ecoenv/env_request.py

@@ -0,0 +1,51 @@
+
+import hashlib
+import ee
+import os
+from pathlib import Path
+import pandas as pd
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from requests_cache import logger
+
+from .sentinel import get_sentinel_properties
+from .worldclim import get_average_temperature_and_precipation
+
+path_root = Path(__file__).resolve().parent
+    
+def autenticateEE(project):
+    ee.Authenticate()
+    ee.Initialize(project=project)    
+
+
+def get_environment_data(gdf, ndvi=True, ndwi=True, temperature=True, precipitation=True):
+    if not (ndvi or ndwi or temperature or precipitation):
+        raise ValueError("At least one of the following parameters must be True: ndvi, ndwi, temperature, precipitation.")
+         
+    index_list = []
+    if ndvi:
+        index_list.append('NDVI')
+    if ndwi:
+        index_list.append('NDWI')
+    if temperature:
+        index_list.append('Temperature')
+    if precipitation:    
+        index_list.append('Precipitation')  
+    try:
+        env_data = None
+        logger.info("Fetching fresh data from sources...")
+
+        if ndvi or ndwi:
+            env_data = get_sentinel_properties(gdf, 250, ndvi, ndwi)
+
+        if temperature or precipitation:
+            if(env_data is None):
+                env_data = get_average_temperature_and_precipation(gdf, batch_size=5000, temperature=temperature, precipitation=precipitation)
+            else: 
+                env_data = get_average_temperature_and_precipation(env_data, batch_size=5000, temperature=temperature, precipitation=precipitation)
+        
+        return env_data
+        
+    except Exception as e:
+        logger.error(f"Critical error retrieving environment data: {e}", exc_info=True)
+        return pd.DataFrame() 

ecoenv-0.1.0/ecoenv/sentinel.py

@@ -0,0 +1,197 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import hashlib
+import ee
+import geopandas as gpd
+import pandas as pd
+from datetime import date, timedelta
+import json
+from pathlib import Path
+from diskcache import Cache
+
+NDVI = True
+NDWI = True
+
+path_root = Path(__file__).resolve().parent
+
+cache = Cache(path_root / ".sentinel_cache")
+
+
+def chunk_gdf(gdf, size=500):
+    n = len(gdf)
+    for i in range(0, n, size):
+        yield gdf.iloc[i:i+size]
+
+
+def add_index(img):
+    index = []
+
+    if NDVI:
+        index.append(img.normalizedDifference(['B8', 'B4']).rename('NDVI'))
+
+    if NDWI:
+        index.append(img.normalizedDifference(['B3', 'B8']).rename('NDWI'))
+
+    return img.addBands(index)
+
+
+def generate_cache_key(gdf, ndvi, ndwi):
+    lat_min = gdf.geometry.bounds['miny'].min()
+    lat_max = gdf.geometry.bounds['maxy'].max()
+    lon_min = gdf.geometry.bounds['minx'].min()
+    lon_max = gdf.geometry.bounds['maxx'].max()
+
+    date_min = gdf['eventDate'].min()
+    date_max = gdf['eventDate'].max()
+
+    normalized = {
+        "lat_min": float(lat_min),
+        "lat_max": float(lat_max),
+        "lon_min": float(lon_min),
+        "lon_max": float(lon_max),
+        "date_min": str(date_min),
+        "date_max": str(date_max),
+        "ndvi": ndvi,
+        "ndwi": ndwi,
+        "size": len(gdf)
+    }
+
+    return hashlib.md5(
+        json.dumps(normalized, sort_keys=True).encode()
+    ).hexdigest()
+
+
+def get_index_from_sentinel_batch(batch, ndvi, ndwi):
+
+    print(f"Processing batch: {len(batch)}")
+
+    if pd.Timestamp(batch['eventDate'].max()) < pd.Timestamp('2019-01-01'):
+        startDate = date.strftime(date.today() - timedelta(30), '%Y-%m-%d')
+        endDate = date.strftime(date.today(), '%Y-%m-%d')
+    else:
+        startDate = batch['eventDate'].min()
+        endDate = batch['eventDate'].max()
+
+    index = []
+    if ndvi:
+        index.append('NDVI')
+    if ndwi:
+        index.append('NDWI')
+
+    img = (
+        ee.ImageCollection('COPERNICUS/S2_SR_HARMONIZED')
+        .filterDate(startDate, endDate)
+        .map(add_index)
+        .select(index)
+        .median()
+    )
+
+    batch['eventDate'] = batch['eventDate'].astype(str)
+    geojson = json.loads(batch.to_json())
+    fc = ee.FeatureCollection(geojson)
+
+    sampled = img.reduceRegions(
+        collection=fc,
+        reducer=ee.Reducer.mean(),
+        scale=30
+    )
+
+    result = sampled.getInfo()
+
+    gdf_out = gpd.GeoDataFrame.from_features(
+        result["features"],
+        crs="EPSG:4326"
+    )
+
+    if not ndvi or not ndwi:
+        gdf_out = gdf_out.rename(columns={'mean': index[0]})
+
+    return gdf_out
+
+def get_sentinel_properties(
+    gdf,
+    batch_size=150,
+    ndvi=True,
+    ndwi=True
+):
+
+    if not ndvi and not ndwi:
+        raise ValueError("At least one of NDVI or NDWI must be True.")
+
+    gdf = gdf.sort_values("eventDate", ascending=True)
+
+    cached_rows = []
+    missing_rows = []
+
+    # 🔍 Separa registros já existentes dos que faltam
+    for _, row in gdf.iterrows():
+        key = generate_point_key(row, ndvi, ndwi)
+
+        if key in cache:
+            cached_rows.append(cache[key])
+        else:
+            missing_rows.append(row)
+
+    print(f"cached: {len(cached_rows)}")
+    print(f"missing: {len(missing_rows)}")
+
+    new_results = []
+
+    # 🔥 Busca só os faltantes
+    if missing_rows:
+        missing_gdf = gpd.GeoDataFrame(
+            missing_rows,
+            geometry=gdf.geometry.name,
+            crs=gdf.crs
+        )
+
+        batches = list(chunk_gdf(missing_gdf, batch_size))
+
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            futures = [
+                executor.submit(
+                    get_index_from_sentinel_batch,
+                    batch,
+                    ndvi,
+                    ndwi
+                )
+                for batch in batches
+            ]
+
+            for future in futures:
+                result = future.result()
+                new_results.append(result)
+
+        if new_results:
+            new_df = pd.concat(new_results, ignore_index=True)
+            
+            for _, row in new_df.iterrows():
+                key = generate_point_key(row, ndvi, ndwi)
+                cache.set(key, row)
+
+        else:
+            new_df = pd.DataFrame()
+
+    else:
+        new_df = pd.DataFrame()
+
+    if cached_rows:
+        cached_df = pd.DataFrame(cached_rows)
+    else:
+        cached_df = pd.DataFrame()
+
+    final_df = pd.concat([cached_df, new_df], ignore_index=True)
+
+    return final_df
+
+def generate_point_key(row, ndvi, ndwi):
+    normalized = {
+        "lat": float(row["latitude"]),
+        "lon": float(row["longitude"]),
+        "date": str(row["eventDate"]),
+        "ndvi": ndvi,
+        "ndwi": ndwi
+    }
+
+    return hashlib.md5(
+        json.dumps(normalized, sort_keys=True).encode()
+    ).hexdigest()

ecoenv-0.1.0/ecoenv/worldclim.py

@@ -0,0 +1,154 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import hashlib
+import ee
+import geopandas as gpd
+import pandas as pd
+import json
+from pathlib import Path
+from diskcache import Cache
+
+path_root = Path(__file__).resolve().parent
+
+# 🔥 Cache persistente
+cache = Cache(path_root / ".worldclim_cache")
+
+
+def chunk_gdf(gdf, size=500):
+    n = len(gdf)
+    for i in range(0, n, size):
+        yield gdf.iloc[i:i+size]
+
+def generate_cache_key(gdf, index, scale):
+    if isinstance(gdf, pd.DataFrame):
+        gdf = gpd.GeoDataFrame(gdf, geometry=gpd.points_from_xy(gdf.longitude, gdf.latitude), crs='EPSG:4326')
+
+    if not isinstance(gdf, gpd.GeoDataFrame):
+        raise TypeError(
+            f"Expected GeoDataFrame, got {type(gdf)}"
+        )
+
+    if gdf.geometry is None:
+        raise ValueError("GeoDataFrame has no geometry column.")
+
+    if gdf.empty:
+        raise ValueError("GeoDataFrame is empty.")
+
+    bounds = gdf.total_bounds 
+
+    lat_min, lon_min, lat_max, lon_max = (
+        bounds[1],  # miny
+        bounds[0],  # minx
+        bounds[3],  # maxy
+        bounds[2],  # maxx
+    )
+
+    date_min = gdf['eventDate'].min()
+    date_max = gdf['eventDate'].max()
+
+    normalized = {
+        "lat_min": float(lat_min),
+        "lat_max": float(lat_max),
+        "lon_min": float(lon_min),
+        "lon_max": float(lon_max),
+        "date_min": str(date_min),
+        "date_max": str(date_max),
+        "index": index,
+        "scale": scale,
+        "size": len(gdf)
+    }
+
+    return hashlib.md5(
+        json.dumps(normalized, sort_keys=True).encode()
+    ).hexdigest()
+
+def add_worldclim_properties(gdf, img, scale):
+
+    print(f"Processing {len(gdf)} records...")
+
+    gdf['eventDate'] = gdf['eventDate'].astype(str)
+    geojson = json.loads(gdf.to_json())
+    fc = ee.FeatureCollection(geojson)
+
+    sampled = img.reduceRegions(
+        collection=fc,
+        reducer=ee.Reducer.mean(),
+        scale=scale
+    )
+
+    result = sampled.getInfo()
+
+    gdf_out = gpd.GeoDataFrame.from_features(
+        result["features"],
+        crs="EPSG:4326"
+    )
+
+    return gdf_out
+
+
+def get_average_temperature_and_precipation(
+    gdf,
+    scale=1000,
+    batch_size=5000,
+    temperature=True,
+    precipitation=True
+):
+
+    index = []
+
+    if temperature:
+        index.append("tavg")
+
+    if precipitation:
+        index.append("prec")
+
+    if not index:
+        raise ValueError("At least temperature or precipitation must be True.")
+
+    cache_key = generate_cache_key(gdf, index, scale)
+
+    if cache_key in cache:
+        print("DiskCache full hit")
+        return cache[cache_key]
+
+    print("Downloading full dataset from GEE...")
+
+    img = (
+        ee.ImageCollection("WORLDCLIM/V1/MONTHLY")
+        .select(index)
+        .mean()
+        .multiply(0.1)
+    )
+
+    if len(gdf) > batch_size:
+
+        all_batches = []
+
+        with ThreadPoolExecutor(max_workers=4) as executor:
+
+            futures = [
+                executor.submit(
+                    add_worldclim_properties,
+                    batch,
+                    img,
+                    scale
+                )
+                for batch in chunk_gdf(gdf, size=batch_size)
+            ]
+
+            for future in as_completed(futures):
+                all_batches.append(future.result())
+
+        final_gdf = gpd.GeoDataFrame(
+            pd.concat(all_batches, ignore_index=True),
+            crs="EPSG:4326"
+        )
+
+    else:
+        final_gdf = add_worldclim_properties(gdf, img, scale)
+
+    if not temperature or not precipitation:
+        final_gdf = final_gdf.rename(columns={"mean": index[0]})
+
+    cache.set(cache_key, final_gdf)
+
+    return final_gdf

ecoenv-0.1.0/ecoenv.egg-info/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: ecoenv
+Version: 0.1.0
+Summary: A Python library for ecological data collection and environmental analysis
+Author: Ane Simões
+Author-email: anes.2017@alunos.utfpr.edu.br
+License: MIT
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ee
+Requires-Dist: pandas
+Requires-Dist: requests
+Requires-Dist: python-dotenv
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# USAGE.md
+
+## Overview
+
+**ecoenv** is a library designed to facilitate data management and processing for scientific and research applications.
+
+## Getting Started
+
+### Installation
+
+```bash
+pip install ecoenv
+```
+
+### Basic Usage
+
+```python
+import ecoenv
+
+
+ecoenv.autenticateEE('project_name')
+ecoenv.get_environment_data(gdf, ndvi=True, ndwi=True, temperature=True, precipitation=True)
+```
+## Functions
+- `autenticateEE`: Authenticates the user with the Earth Engine API using the specified project name.
+- `get_environment_data`: Retrieves environmental data based on the provided geospatial data frame (gdf) and specified parameters (ndvi, ndwi, temperature, precipitation).
+

ecoenv-0.1.0/ecoenv.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+setup.py
+ecoenv/__init__.py
+ecoenv/env_request.py
+ecoenv/globi.py
+ecoenv/sentinel.py
+ecoenv/worldclim.py
+ecoenv.egg-info/PKG-INFO
+ecoenv.egg-info/SOURCES.txt
+ecoenv.egg-info/dependency_links.txt
+ecoenv.egg-info/requires.txt
+ecoenv.egg-info/top_level.txt
+tests/test_ecoenv.py

ecoenv-0.1.0/ecoenv.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ecoenv-0.1.0/ecoenv.egg-info/requires.txt

@@ -0,0 +1,4 @@
+ee
+pandas
+requests
+python-dotenv

ecoenv-0.1.0/ecoenv.egg-info/top_level.txt

@@ -0,0 +1 @@
+ecoenv

ecoenv-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ecoenv-0.1.0/setup.py

@@ -0,0 +1,20 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='ecoenv',
+    version='0.1.0',
+    description='A Python library for ecological data collection and environmental analysis',
+    long_description=open('USAGE.md').read(),
+    long_description_content_type='text/markdown',
+    author='Ane Simões',
+    author_email='anes.2017@alunos.utfpr.edu.br',
+    packages=find_packages(),
+    install_requires=[
+        "ee",
+        "pandas",
+        "requests",
+        "python-dotenv",
+    ],
+    license='MIT',
+    python_requires='>=3.7',
+)

ecoenv-0.1.0/tests/test_ecoenv.py

@@ -0,0 +1,387 @@
+import pytest
+import pandas as pd
+import geopandas as gpd
+from shapely.geometry import Point
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+
+from ecoenv.env_request import autenticateEE, get_environment_data
+from ecoenv.sentinel import (
+    chunk_gdf,
+    generate_cache_key as sentinel_cache_key,
+    generate_point_key,
+    get_index_from_sentinel_batch,
+    get_sentinel_properties,
+    add_index,
+)
+from ecoenv.worldclim import (
+    chunk_gdf as worldclim_chunk_gdf,
+    generate_cache_key as worldclim_cache_key,
+    add_worldclim_properties,
+    get_average_temperature_and_precipation,
+)
+
+
+@pytest.fixture
+def sample_gdf():
+    """Create a sample GeoDataFrame for testing."""
+    data = {
+        'latitude': [10.0, 20.0, 30.0],
+        'longitude': [50.0, 60.0, 70.0],
+        'eventDate': ['2020-01-01', '2020-06-15', '2021-01-01'],
+    }
+    gdf = gpd.GeoDataFrame(
+        data,
+        geometry=[Point(50, 10), Point(60, 20), Point(70, 30)],
+        crs='EPSG:4326'
+    )
+    return gdf
+
+
+@pytest.fixture
+def sample_gdf_with_dates():
+    """Create a GeoDataFrame with proper date formatting."""
+    data = {
+        'latitude': [10.0, 20.0],
+        'longitude': [50.0, 60.0],
+        'eventDate': pd.to_datetime(['2020-01-01', '2020-06-15']),
+    }
+    gdf = gpd.GeoDataFrame(
+        data,
+        geometry=[Point(50, 10), Point(60, 20)],
+        crs='EPSG:4326'
+    )
+    return gdf
+
+
+class TestEnvRequest:
+    """Tests for env_request.py"""
+
+    @patch('ecoenv.env_request.ee')
+    def test_autenticateEE(self, mock_ee):
+        """Test authentication with Earth Engine."""
+        autenticateEE("test-project")
+        mock_ee.Authenticate.assert_called_once()
+        mock_ee.Initialize.assert_called_once_with(project="test-project")
+
+    @patch('ecoenv.env_request.get_sentinel_properties')
+    @patch('ecoenv.env_request.get_average_temperature_and_precipation')
+    def test_get_environment_data_all_true(self, mock_temp, mock_sentinel, sample_gdf):
+        """Test get_environment_data with all parameters True."""
+        mock_sentinel.return_value = sample_gdf
+        mock_temp.return_value = sample_gdf
+        
+        result = get_environment_data(
+            sample_gdf,
+            ndvi=True,
+            ndwi=True,
+            temperature=True,
+            precipitation=True
+        )
+        
+        assert mock_sentinel.called
+        assert mock_temp.called
+
+    @patch('ecoenv.env_request.get_sentinel_properties')
+    def test_get_environment_data_ndvi_only(self, mock_sentinel, sample_gdf):
+        """Test get_environment_data with only NDVI."""
+        mock_sentinel.return_value = sample_gdf
+        
+        result = get_environment_data(
+            sample_gdf,
+            ndvi=True,
+            ndwi=False,
+            temperature=False,
+            precipitation=False
+        )
+        
+        mock_sentinel.assert_called_once()
+
+    def test_get_environment_data_all_false(self, sample_gdf):
+        """Test that ValueError is raised when all parameters are False."""
+        with pytest.raises(ValueError):
+            get_environment_data(
+                sample_gdf,
+                ndvi=False,
+                ndwi=False,
+                temperature=False,
+                precipitation=False
+            )
+
+    @patch('ecoenv.env_request.get_sentinel_properties')
+    @patch('ecoenv.env_request.get_average_temperature_and_precipation')
+    def test_get_environment_data_exception(self, mock_temp, mock_sentinel, sample_gdf):
+        """Test exception handling in get_environment_data."""
+        mock_sentinel.side_effect = Exception("API Error")
+        
+        result = get_environment_data(sample_gdf)
+        
+        assert isinstance(result, pd.DataFrame)
+        assert result.empty
+
+
+class TestSentinel:
+    """Tests for sentinel.py"""
+
+    def test_chunk_gdf(self, sample_gdf):
+        """Test chunking of GeoDataFrame."""
+        chunks = list(chunk_gdf(sample_gdf, size=1))
+        assert len(chunks) == 3
+        assert len(chunks[0]) == 1
+
+    def test_chunk_gdf_size_larger_than_gdf(self, sample_gdf):
+        """Test chunking when chunk size is larger than GeoDataFrame."""
+        chunks = list(chunk_gdf(sample_gdf, size=10))
+        assert len(chunks) == 1
+        assert len(chunks[0]) == 3
+
+    def test_generate_point_key(self, sample_gdf_with_dates):
+        """Test generation of cache key for a point."""
+        row = sample_gdf_with_dates.iloc[0]
+        key = generate_point_key(row, ndvi=True, ndwi=True)
+        
+        assert isinstance(key, str)
+        assert len(key) == 32  # MD5 hash length
+
+    def test_generate_point_key_consistency(self, sample_gdf_with_dates):
+        """Test that same input generates same key."""
+        row = sample_gdf_with_dates.iloc[0]
+        key1 = generate_point_key(row, ndvi=True, ndwi=False)
+        key2 = generate_point_key(row, ndvi=True, ndwi=False)
+        
+        assert key1 == key2
+
+    def test_generate_point_key_different_params(self, sample_gdf_with_dates):
+        """Test that different parameters generate different keys."""
+        row = sample_gdf_with_dates.iloc[0]
+        key1 = generate_point_key(row, ndvi=True, ndwi=False)
+        key2 = generate_point_key(row, ndvi=False, ndwi=True)
+        
+        assert key1 != key2
+
+    @patch('ecoenv.sentinel.ee')
+    def test_add_index(self, mock_ee):
+        """Test add_index function."""
+        mock_img = MagicMock()
+        mock_ndvi = MagicMock()
+        mock_ndwi = MagicMock()
+        
+        mock_img.normalizedDifference.side_effect = [mock_ndvi, mock_ndwi]
+        mock_ndvi.rename.return_value = mock_ndvi
+        mock_ndwi.rename.return_value = mock_ndwi
+        mock_img.addBands.return_value = mock_img
+        
+        result = add_index(mock_img)
+        
+        assert mock_img.normalizedDifference.called
+        assert mock_img.addBands.called
+
+    def test_sentinel_cache_key_generation(self, sample_gdf_with_dates):
+        """Test cache key generation for sentinel data."""
+        key = sentinel_cache_key(sample_gdf_with_dates, ndvi=True, ndwi=True)
+        
+        assert isinstance(key, str)
+        assert len(key) == 32
+
+    def test_sentinel_cache_key_different_dates(self, sample_gdf_with_dates):
+        """Test that different dates generate different cache keys."""
+        gdf2 = sample_gdf_with_dates.copy()
+        gdf2['eventDate'] = pd.to_datetime(['2019-01-01', '2019-06-15'])
+        
+        key1 = sentinel_cache_key(sample_gdf_with_dates, ndvi=True, ndwi=True)
+        key2 = sentinel_cache_key(gdf2, ndvi=True, ndwi=True)
+        
+        assert key1 != key2
+
+    def test_get_sentinel_properties_ndvi_ndwi_both_false(self, sample_gdf_with_dates):
+        """Test ValueError when both NDVI and NDWI are False."""
+        with pytest.raises(ValueError):
+            get_sentinel_properties(sample_gdf_with_dates, ndvi=False, ndwi=False)
+
+    @patch('ecoenv.sentinel.get_index_from_sentinel_batch')
+    def test_get_sentinel_properties_single_batch(self, mock_batch, sample_gdf_with_dates):
+        """Test get_sentinel_properties with single batch."""
+        mock_batch.return_value = sample_gdf_with_dates
+        
+        result = get_sentinel_properties(
+            sample_gdf_with_dates,
+            batch_size=150,
+            ndvi=True,
+            ndwi=True
+        )
+        
+        assert isinstance(result, pd.DataFrame)
+
+
+class TestWorldclim:
+    """Tests for worldclim.py"""
+
+    def test_worldclim_chunk_gdf(self, sample_gdf):
+        """Test chunking of worldclim GeoDataFrame."""
+        chunks = list(worldclim_chunk_gdf(sample_gdf, size=2))
+        assert len(chunks) == 2
+
+    def test_worldclim_generate_cache_key_with_geodataframe(self, sample_gdf_with_dates):
+        """Test cache key generation for worldclim with GeoDataFrame."""
+        key = worldclim_cache_key(sample_gdf_with_dates, ["tavg"], 1000)
+        
+        assert isinstance(key, str)
+        assert len(key) == 32
+
+    def test_worldclim_generate_cache_key_with_dataframe(self):
+        """Test cache key generation with regular DataFrame."""
+        data = {
+            'latitude': [10.0, 20.0],
+            'longitude': [50.0, 60.0],
+            'eventDate': pd.to_datetime(['2020-01-01', '2020-06-15']),
+        }
+        df = pd.DataFrame(data)
+        
+        key = worldclim_cache_key(df, ["tavg"], 1000)
+        
+        assert isinstance(key, str)
+        assert len(key) == 32
+
+    def test_worldclim_generate_cache_key_invalid_type(self):
+        """Test that invalid type raises TypeError."""
+        with pytest.raises(TypeError):
+            worldclim_cache_key([1, 2, 3], ["tavg"], 1000)
+
+    def test_worldclim_generate_cache_key_empty_gdf(self, sample_gdf_with_dates):
+        """Test that empty GeoDataFrame raises ValueError."""
+        empty_gdf = sample_gdf_with_dates.iloc[0:0]
+        
+        with pytest.raises(ValueError):
+            worldclim_cache_key(empty_gdf, ["tavg"], 1000)
+
+    @patch('ecoenv.worldclim.ee')
+    def test_add_worldclim_properties(self, mock_ee, sample_gdf_with_dates):
+        """Test adding worldclim properties to GeoDataFrame."""
+        mock_img = MagicMock()
+        mock_fc = MagicMock()
+        mock_ee.FeatureCollection.return_value = mock_fc
+        
+        mock_sampled = MagicMock()
+        mock_img.reduceRegions.return_value = mock_sampled
+        mock_sampled.getInfo.return_value = {
+            "features": [
+                {
+                    "type": "Feature",
+                    "geometry": {"type": "Point", "coordinates": [50, 10]},
+                    "properties": {"tavg": 25.0}
+                }
+            ]
+        }
+        
+        result = add_worldclim_properties(sample_gdf_with_dates, mock_img, 1000)
+        
+        assert isinstance(result, gpd.GeoDataFrame)
+
+    def test_get_average_temperature_and_precipation_no_index(self, sample_gdf_with_dates):
+        """Test ValueError when both temperature and precipitation are False."""
+        with pytest.raises(ValueError):
+            get_average_temperature_and_precipation(
+                sample_gdf_with_dates,
+                temperature=False,
+                precipitation=False
+            )
+
+    @patch('ecoenv.worldclim.add_worldclim_properties')
+    @patch('ecoenv.worldclim.ee')
+    def test_get_average_temperature_small_batch(
+        self,
+        mock_ee,
+        mock_add,
+        sample_gdf_with_dates
+    ):
+        """Test temperature and precipitation retrieval for small batch."""
+        mock_add.return_value = sample_gdf_with_dates
+        mock_collection = MagicMock()
+        mock_ee.ImageCollection.return_value = mock_collection
+        mock_collection.select.return_value = mock_collection
+        mock_collection.mean.return_value = mock_collection
+        mock_collection.multiply.return_value = MagicMock()
+        
+        result = get_average_temperature_and_precipation(
+            sample_gdf_with_dates,
+            batch_size=5000,
+            temperature=True,
+            precipitation=True
+        )
+        
+        assert isinstance(result, gpd.GeoDataFrame)
+
+    @patch('ecoenv.worldclim.add_worldclim_properties')
+    @patch('ecoenv.worldclim.ee')
+    def test_get_average_temperature_large_batch(
+        self,
+        mock_ee,
+        mock_add,
+        sample_gdf_with_dates
+    ):
+        """Test temperature retrieval with multiple batches."""
+        large_gdf = pd.concat(
+            [sample_gdf_with_dates] * 3000,
+            ignore_index=True
+        )
+        large_gdf = gpd.GeoDataFrame(
+            large_gdf,
+            geometry=sample_gdf_with_dates.geometry,
+            crs='EPSG:4326'
+        )
+        
+        mock_add.return_value = large_gdf.iloc[:1000]
+        mock_collection = MagicMock()
+        mock_ee.ImageCollection.return_value = mock_collection
+        mock_collection.select.return_value = mock_collection
+        mock_collection.mean.return_value = mock_collection
+        mock_collection.multiply.return_value = MagicMock()
+        
+        result = get_average_temperature_and_precipation(
+            large_gdf,
+            batch_size=1000,
+            temperature=True,
+            precipitation=False
+        )
+        
+        assert isinstance(result, gpd.GeoDataFrame)
+
+    @patch('ecoenv.worldclim.ee')
+    def test_get_average_temperature_only(self, mock_ee, sample_gdf_with_dates):
+        """Test retrieving only temperature data."""
+        mock_collection = MagicMock()
+        mock_ee.ImageCollection.return_value = mock_collection
+        mock_collection.select.return_value = mock_collection
+        mock_collection.mean.return_value = mock_collection
+        mock_collection.multiply.return_value = MagicMock()
+        
+        with patch('ecoenv.worldclim.add_worldclim_properties') as mock_add:
+            mock_add.return_value = sample_gdf_with_dates
+            
+            result = get_average_temperature_and_precipation(
+                sample_gdf_with_dates,
+                temperature=True,
+                precipitation=False
+            )
+            
+            assert isinstance(result, gpd.GeoDataFrame)
+
+    @patch('ecoenv.worldclim.ee')
+    def test_get_average_precipitation_only(self, mock_ee, sample_gdf_with_dates):
+        """Test retrieving only precipitation data."""
+        mock_collection = MagicMock()
+        mock_ee.ImageCollection.return_value = mock_collection
+        mock_collection.select.return_value = mock_collection
+        mock_collection.mean.return_value = mock_collection
+        mock_collection.multiply.return_value = MagicMock()
+        
+        with patch('ecoenv.worldclim.add_worldclim_properties') as mock_add:
+            mock_add.return_value = sample_gdf_with_dates
+            
+            result = get_average_temperature_and_precipation(
+                sample_gdf_with_dates,
+                temperature=False,
+                precipitation=True
+            )
+            
+            assert isinstance(result, gpd.GeoDataFrame)