ee-client 2.0.3__tar.gz → 2.2.0__tar.gz

{ee_client-2.0.3 → ee_client-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ee-client
-Version: 2.0.3
+Version: 2.2.0
 Summary: extends the capabilities of the earthengine-api by providing custom session management and client interactions
 Author-email: Daniel Guerrero <dfgm2006@gmail.com>
 Project-URL: Homepage, https://github.com/dfguerrerom/ee-client
@@ -32,15 +32,22 @@ Dynamic: license-file
 Earth Engine Client 🌎
 ==============================
 
-The **Earth Engine Session Client** is a Python package that extends the Google Earth Engine (GEE) API by introducing multi-user session management through a custom authentication. Unlike the standard GEE API—which relies on a global session object and does not support multi-user environments—this client ensures that each session is authenticated and managed independently.
+The **Earth Engine Session Client** is a Python package that extends the Google Earth Engine (GEE) API by introducing multi-user session management through custom authentication. 
+
+**Why This Package?**
+
+While Google Earth Engine applications can be created using a global service account, this approach has significant limitations: users cannot access their private GEE assets without making them public. This package solves this problem by handling custom authentication, allowing each user to access their own private assets securely.
+
+Unlike the standard GEE API—which relies on a global session object and does not support multi-user environments—this client ensures that each session is authenticated and managed independently with user-specific credentials.
 
 Each session is instantiated via the ``EESession`` class, currently only accepts SEPAL headers as its only parameter. **A valid ``sepal-session-id`` cookie must be present in these headers**, as it is used to retrieve the corresponding GEE credentials. Once authenticated, the session exposes an ``operations`` property that provides easy access to key API methods.
 
 Key Features
 ------------
 
+- **Custom User Authentication**: Enable users to access their private GEE assets without requiring them to be public, solving the limitation of global service account approaches.
 - **SEPAL-based Initialization**: Create sessions using SEPAL headers. The required ``sepal-session-id`` cookie is automatically used to retrieve GEE credentials.
-- **Custom Session Management**: Encapsulate user-specific credentials and project data in an ``EESession`` object.
+- **Multi-User Session Management**: Encapsulate user-specific credentials and project data in independent ``EESession`` objects.
 - **Enhanced API Operations**: Access GEE functionalities via the ``operations`` property, which includes methods such as:
   - ``get_info``: Retrieve detailed information about an Earth Engine object.
   - ``get_map_id``: Generate a map ID for an Earth Engine image.

{ee_client-2.0.3 → ee_client-2.2.0}/README.rst

@@ -1,15 +1,22 @@
 Earth Engine Client 🌎
 ==============================
 
-The **Earth Engine Session Client** is a Python package that extends the Google Earth Engine (GEE) API by introducing multi-user session management through a custom authentication. Unlike the standard GEE API—which relies on a global session object and does not support multi-user environments—this client ensures that each session is authenticated and managed independently.
+The **Earth Engine Session Client** is a Python package that extends the Google Earth Engine (GEE) API by introducing multi-user session management through custom authentication. 
+
+**Why This Package?**
+
+While Google Earth Engine applications can be created using a global service account, this approach has significant limitations: users cannot access their private GEE assets without making them public. This package solves this problem by handling custom authentication, allowing each user to access their own private assets securely.
+
+Unlike the standard GEE API—which relies on a global session object and does not support multi-user environments—this client ensures that each session is authenticated and managed independently with user-specific credentials.
 
 Each session is instantiated via the ``EESession`` class, currently only accepts SEPAL headers as its only parameter. **A valid ``sepal-session-id`` cookie must be present in these headers**, as it is used to retrieve the corresponding GEE credentials. Once authenticated, the session exposes an ``operations`` property that provides easy access to key API methods.
 
 Key Features
 ------------
 
+- **Custom User Authentication**: Enable users to access their private GEE assets without requiring them to be public, solving the limitation of global service account approaches.
 - **SEPAL-based Initialization**: Create sessions using SEPAL headers. The required ``sepal-session-id`` cookie is automatically used to retrieve GEE credentials.
-- **Custom Session Management**: Encapsulate user-specific credentials and project data in an ``EESession`` object.
+- **Multi-User Session Management**: Encapsulate user-specific credentials and project data in independent ``EESession`` objects.
 - **Enhanced API Operations**: Access GEE functionalities via the ``operations`` property, which includes methods such as:
   - ``get_info``: Retrieve detailed information about an Earth Engine object.
   - ``get_map_id``: Generate a map ID for an Earth Engine image.

{ee_client-2.0.3 → ee_client-2.2.0}/ee_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ee-client
-Version: 2.0.3
+Version: 2.2.0
 Summary: extends the capabilities of the earthengine-api by providing custom session management and client interactions
 Author-email: Daniel Guerrero <dfgm2006@gmail.com>
 Project-URL: Homepage, https://github.com/dfguerrerom/ee-client
@@ -32,15 +32,22 @@ Dynamic: license-file
 Earth Engine Client 🌎
 ==============================
 
-The **Earth Engine Session Client** is a Python package that extends the Google Earth Engine (GEE) API by introducing multi-user session management through a custom authentication. Unlike the standard GEE API—which relies on a global session object and does not support multi-user environments—this client ensures that each session is authenticated and managed independently.
+The **Earth Engine Session Client** is a Python package that extends the Google Earth Engine (GEE) API by introducing multi-user session management through custom authentication. 
+
+**Why This Package?**
+
+While Google Earth Engine applications can be created using a global service account, this approach has significant limitations: users cannot access their private GEE assets without making them public. This package solves this problem by handling custom authentication, allowing each user to access their own private assets securely.
+
+Unlike the standard GEE API—which relies on a global session object and does not support multi-user environments—this client ensures that each session is authenticated and managed independently with user-specific credentials.
 
 Each session is instantiated via the ``EESession`` class, currently only accepts SEPAL headers as its only parameter. **A valid ``sepal-session-id`` cookie must be present in these headers**, as it is used to retrieve the corresponding GEE credentials. Once authenticated, the session exposes an ``operations`` property that provides easy access to key API methods.
 
 Key Features
 ------------
 
+- **Custom User Authentication**: Enable users to access their private GEE assets without requiring them to be public, solving the limitation of global service account approaches.
 - **SEPAL-based Initialization**: Create sessions using SEPAL headers. The required ``sepal-session-id`` cookie is automatically used to retrieve GEE credentials.
-- **Custom Session Management**: Encapsulate user-specific credentials and project data in an ``EESession`` object.
+- **Multi-User Session Management**: Encapsulate user-specific credentials and project data in independent ``EESession`` objects.
 - **Enhanced API Operations**: Access GEE functionalities via the ``operations`` property, which includes methods such as:
   - ``get_info``: Retrieve detailed information about an Earth Engine object.
   - ``get_map_id``: Generate a map ID for an Earth Engine image.

{ee_client-2.0.3 → ee_client-2.2.0}/ee_client.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ eeclient/exceptions.py
 eeclient/helpers.py
 eeclient/models.py
 eeclient/oauth_app.py
+eeclient/sepal_credential_mixin.py
 eeclient/tasks.py
 eeclient/export/__init__.py
 eeclient/export/image.py

{ee_client-2.0.3 → ee_client-2.2.0}/eeclient/__init__.py

@@ -1,6 +1,6 @@
 __title__ = "eeclient"
 __summary__ = "A client for Google Earth Engine"
-__version__ = "2.0.3"
+__version__ = "2.2.0"
 
 __author__ = "Daniel Guerrero"
 __email__ = "dfgm2006@gmail.com"

{ee_client-2.0.3 → ee_client-2.2.0}/eeclient/client.py

@@ -1,14 +1,14 @@
 from typing import Any, Dict, Literal, Optional
 
 import os
-import time
 import asyncio
 import httpx
 import logging
 from contextlib import asynccontextmanager
 
 from eeclient.exceptions import EEClientError, EERestException
-from eeclient.models import GEEHeaders, GoogleTokens, SepalHeaders
+from eeclient.models import GEEHeaders, SepalHeaders
+from eeclient.sepal_credential_mixin import SepalCredentialMixin
 
 import eeclient.export as _export_module
 import eeclient.data as _operations_module
@@ -33,8 +33,12 @@ SEPAL_API_DOWNLOAD_URL = None
 VERIFY_SSL = True
 
 
-class EESession:
-    def __init__(self, sepal_headers: SepalHeaders, enforce_project_id: bool = True):
+class EESession(SepalCredentialMixin):
+    def __init__(
+        self,
+        sepal_headers: Optional[SepalHeaders] = None,
+        enforce_project_id: bool = True,
+    ):
         """Session that handles two scenarios to set the headers for Earth Engine API
 
         It can be initialized with the headers sent by SEPAL or with the
@@ -48,46 +52,20 @@ class EESession:
         Raises:
             ValueError: If SEPAL_HOST environment variable is not set
         """
-        # Get and validate environment variables that are required for the session
-        self.sepal_host = os.getenv("SEPAL_HOST")
-        if not self.sepal_host:
-            raise ValueError("SEPAL_HOST environment variable not set")
-
-        self.sepal_api_download_url = (
-            f"https://{self.sepal_host}/api/user-files/download/"
-            "?path=%2F.config%2Fearthengine%2Fcredentials"
-        )
-        self.verify_ssl = not (
-            self.sepal_host == "host.docker.internal"
-            or self.sepal_host == "danielg.sepal.io"
-        )
-
-        self.expiry_date = 0
-        self.max_retries = 3
-        self._credentials = None
-
         self.enforce_project_id = enforce_project_id
-        self.sepal_headers = SepalHeaders.model_validate(sepal_headers)
-        self.sepal_session_id = self.sepal_headers.cookies["SEPAL-SESSIONID"]
-        self.sepal_user_data = self.sepal_headers.sepal_user
-        self.user = self.sepal_user_data.username
+        super().__init__(sepal_headers)
 
         # Create user-specific logger
         self.logger = logging.getLogger(f"eeclient.{self.user}")
 
-        # Initialize credentials from the initial tokens
-        self._google_tokens = self.sepal_user_data.google_tokens
-        if self._google_tokens:
-            self.expiry_date = self._google_tokens.access_token_expiry_date
-            self.project_id = self._google_tokens.project_id
-            self._credentials = self._google_tokens
-        else:
-            self._credentials = None
-            self.project_id = None
-            self.logger.debug(
-                "No credentials found in initial headers. "
+        self.logger.debug(
+            "EESession initialized"
+            if self._credentials
+            else (
+                "EESession created without credentials. "
                 "Call initialize() or use create() to fetch credentials."
             )
+        )
 
     async def initialize(self) -> "EESession":
         """Asynchronously initialize the session by fetching credentials if needed.
@@ -103,11 +81,16 @@ class EESession:
         return self
 
     @classmethod
-    async def create(cls, sepal_headers: SepalHeaders, enforce_project_id: bool = True):
+    async def create(
+        cls,
+        sepal_headers: Optional[SepalHeaders] = None,
+        enforce_project_id: bool = True,
+    ):
         """Asynchronously create an EESession instance.
 
         Args:
-            sepal_headers (SepalHeaders): The headers sent by SEPAL
+            sepal_headers (Optional[SepalHeaders]): The headers sent by SEPAL.
+                If None, will use file-based authentication.
             enforce_project_id (bool, optional): If set, it cannot be changed.
                 Defaults to True.
 
@@ -118,14 +101,10 @@ class EESession:
         return await session.initialize()
 
     async def get_assets_folder(self) -> str:
-        if self.is_expired():
+        if self.needs_credentials_refresh():
             await self.set_credentials()
         return f"projects/{self.project_id}/assets/"
 
-    def is_expired(self) -> bool:
-        """Returns if a token is about to expire"""
-        return (self.expiry_date / 1000) - time.time() < 60
-
     def get_current_headers(self) -> GEEHeaders:
         """Get current headers without refreshing credentials"""
         if not self._credentials:
@@ -133,17 +112,24 @@ class EESession:
 
         self.logger.debug(f"Getting headers with project id: {self.project_id}")
 
+        # Get username based on authentication mode
+        username = (
+            self.sepal_user_data.username
+            if hasattr(self, "sepal_user_data") and self.sepal_user_data
+            else self.user
+        )
+
         data = {
             "x-goog-user-project": self.project_id,
             "Authorization": f"Bearer {self._credentials.access_token}",
-            "Username": self.sepal_user_data.username,
+            "Username": username,
         }
 
         return GEEHeaders.model_validate(data)
 
     async def get_headers(self) -> GEEHeaders:
         """Async method to get headers, refreshing credentials if needed"""
-        if self.is_expired():
+        if self.needs_credentials_refresh():
             await self.set_credentials()
         return self.get_current_headers()
 
@@ -165,68 +151,6 @@ class EESession:
         finally:
             await async_client.aclose()
 
-    async def set_credentials(self) -> None:
-        """
-        Refresh credentials asynchronously.
-        Uses its own HTTP client (thus bypassing get_headers) to avoid recursion.
-        """
-        self.logger.debug(
-            "Token is expired or about to expire; attempting to refresh credentials."
-        )
-        attempt = 0
-        credentials_url = self.sepal_api_download_url
-
-        # Prepare cookies for authentication.
-        sepal_cookies = httpx.Cookies()
-        sepal_cookies.set("SEPAL-SESSIONID", self.sepal_session_id)
-
-        last_status = None
-
-        while attempt < self.max_retries:
-            attempt += 1
-            try:
-                async with httpx.AsyncClient(
-                    cookies=sepal_cookies,
-                    verify=self.verify_ssl,
-                    limits=httpx.Limits(
-                        max_connections=100, max_keepalive_connections=50
-                    ),
-                ) as client:
-                    self.logger.debug(f"Attempt {attempt} to refresh credentials.")
-                    response = await client.get(credentials_url)
-
-                last_status = response.status_code
-
-                if response.status_code == 200:
-                    self._credentials = GoogleTokens.model_validate(response.json())
-                    self.expiry_date = self._credentials.access_token_expiry_date
-                    self.project_id = (
-                        self._credentials.project_id
-                        if self.enforce_project_id
-                        else self.project_id
-                    )
-                    self.logger.debug(
-                        f"Successfully refreshed credentials "
-                        f"!{self._credentials}==================. {self.project_id}"
-                    )
-                    return
-                else:
-                    self.logger.debug(
-                        f"Attempt {attempt}/{self.max_retries} failed with "
-                        f"status code: {response.status_code}."
-                    )
-            except Exception as e:
-                self.logger.error(
-                    f"Attempt {attempt}/{self.max_retries} "
-                    f"encountered an exception: {e}"
-                )
-            await asyncio.sleep(2**attempt)  # Exponential backoff
-
-        raise ValueError(
-            f"Failed to retrieve credentials after {self.max_retries} attempts, "
-            f"last status code: {last_status}"
-        )
-
     async def rest_call(
         self,
         method: Literal["GET", "POST", "DELETE"],
@@ -246,9 +170,12 @@ class EESession:
             try:
                 async with self.get_client() as client:
                     url_with_project = self.set_url_project(url)
-                    self.logger.debug(
-                        f"Making async (asdf) {method} request to {url_with_project}"
-                    )
+
+                    if "assets" not in url_with_project:
+                        # Do not log assets requests
+                        self.logger.debug(
+                            f"Making async  {method} request to {url_with_project}"
+                        )
                     response = await client.request(
                         method, url_with_project, json=data, params=params
                     )
@@ -356,7 +283,7 @@ class EESession:
                 last_error = e
                 error_type = type(e).__name__
                 self.logger.error(
-                    f"Unexpected error in rest_call ({error_type}): " f"{str(e)}"
+                    f"Unexpected error in rest_call ({error_type}): {str(e)}"
                 )
 
                 import traceback

{ee_client-2.0.3 → ee_client-2.2.0}/eeclient/export/image.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
 from ee import serializer
 import ee
 import logging
+from eeclient.tasks import Task
 
 log = logging.getLogger("eeclient.export.image")
 
@@ -127,11 +128,14 @@ async def _export_image(
     scale: Optional[float] = None,
     crs: Optional[str] = None,
     crs_transform: Optional[AffineTransform] = None,
-) -> dict:
+) -> Task:
     """
-    Export a table to either Google Drive or Earth Engine Asset.
+    Export an image to either Google Drive or Earth Engine Asset.
 
     Exactly one of drive_options or asset_options must be provided.
+
+    Returns:
+        Task: The export task response from the API
     """
     if (drive_options is None and asset_options is None) or (
         drive_options is not None and asset_options is not None
@@ -177,7 +181,8 @@ async def _export_image(
     log.debug(f"Exporting image with params: {request_params}")
 
     url = "{earth_engine_api_url}/projects/{project}/image:export"
-    return await client.rest_call("POST", url, data=request_params)
+    response_data = await client.rest_call("POST", url, data=request_params)
+    return Task.model_validate(response_data)
 
 
 async def image_to_drive_async(
@@ -198,8 +203,12 @@ async def image_to_drive_async(
     scale: Optional[float] = None,
     crs: Optional[str] = None,
     crs_transform: Optional[AffineTransform] = None,
-) -> dict:
-    """Abstracts the export of an image to Google Drive."""
+) -> Task:
+    """Abstracts the export of an image to Google Drive.
+
+    Returns:
+        Task: The export task response from the API
+    """
     drive_options = DriveOptions(
         file_format=file_format,
         drive_destination=DriveDestination(
@@ -240,8 +249,12 @@ async def image_to_asset_async(
     scale: Optional[float] = None,
     crs: Optional[str] = None,
     crs_transform: Optional[AffineTransform] = None,
-) -> dict:
-    """Abstracts the export of an image to Earth Engine Asset."""
+) -> Task:
+    """Abstracts the export of an image to Earth Engine Asset.
+
+    Returns:
+        Task: The export task response from the API
+    """
     asset_options = AssetOptions(
         earth_engine_destination=EarthEngineDestination(name=asset_id),
     )

{ee_client-2.0.3 → ee_client-2.2.0}/eeclient/export/table.py

@@ -7,6 +7,7 @@ if TYPE_CHECKING:
     from eeclient.client import EESession
 
 from ee import serializer, encodable
+from eeclient.tasks import Task
 
 
 class TableFileFormat(str, Enum):
@@ -75,11 +76,14 @@ async def _export_table(
     max_vertices: Optional[int] = None,
     workload_tag: Optional[str] = None,
     priority: Optional[int] = None,
-) -> dict:
+) -> Task:
     """
     Export a table to either Google Drive or Earth Engine Asset.
 
     Exactly one of drive_options or asset_options must be provided.
+
+    Returns:
+        Task: The export task response from the API
     """
     if (drive_options is None and asset_options is None) or (
         drive_options is not None and asset_options is not None
@@ -107,24 +111,30 @@ async def _export_table(
     params = export_options.model_dump(by_alias=True, exclude_none=True)
 
     url = "{earth_engine_api_url}/projects/{project}/table:export"
-    return await client.rest_call("POST", url, data=params)
+    response_data = await client.rest_call("POST", url, data=params)
+    return Task.model_validate(response_data)
 
 
 async def table_to_drive_async(
     client: "EESession",
     collection,
-    filename_prefix: str,
     file_format: TableFileFormat,
+    filename_prefix: str = "",
     folder: Optional[str] = None,
     description: str = "myExportTableTask",
     selectors: Optional[list] = None,
     max_vertices: Optional[int] = None,
     priority: Optional[int] = None,
-) -> dict:
+) -> Task:
     """
     Export a table to Google Drive.
+
+    Returns:
+        Task: The export task response from the API
     """
-    drive_destination = DriveDestination(filename_prefix=filename_prefix, folder=folder)
+    drive_destination = DriveDestination(
+        filename_prefix=filename_prefix or description, folder=folder
+    )
     drive_options = DriveOptions(
         file_format=file_format, drive_destination=drive_destination
     )
@@ -148,9 +158,12 @@ async def table_to_asset_async(
     selectors: Optional[list] = None,
     max_vertices: Optional[int] = None,
     priority: Optional[int] = None,
-) -> dict:
+) -> Task:
     """
     Export a table to Earth Engine Asset.
+
+    Returns:
+        Task: The export task response from the API
     """
     asset_options = AssetOptions(
         earth_engine_destination=EarthEngineDestination(name=asset_id)

{ee_client-2.0.3 → ee_client-2.2.0}/eeclient/helpers.py

@@ -2,7 +2,7 @@ import os
 import requests
 import logging
 from eeclient.models import SepalHeaders, SepalUser
-from typing import Union
+from typing import Optional, Union
 
 from ee.imagecollection import ImageCollection
 from ee.feature import Feature
@@ -59,11 +59,17 @@ def parse_cookie_string(cookie_string):
     return cookies
 
 
-def get_sepal_headers_from_auth():
+def get_sepal_headers_from_auth(
+    sepal_user: Optional[str] = None,
+    sepal_password: Optional[str] = None,
+    sepal_host: Optional[str] = None,
+) -> SepalHeaders:
+
     log.debug("Getting SEPAL headers from authentication")
-    sepal_user = os.getenv("LOCAL_SEPAL_USER")
-    sepal_password = os.getenv("LOCAL_SEPAL_PASSWORD")
-    sepal_host = os.getenv("SEPAL_HOST")
+
+    sepal_user = sepal_user or os.getenv("LOCAL_SEPAL_USER")
+    sepal_password = sepal_password or os.getenv("LOCAL_SEPAL_PASSWORD")
+    sepal_host = sepal_host or os.getenv("SEPAL_HOST")
 
     if not sepal_user or not sepal_password or not sepal_host:
         raise ValueError(

ee_client-2.2.0/eeclient/sepal_credential_mixin.py

@@ -0,0 +1,355 @@
+from eeclient.models import SepalHeaders, GoogleTokens
+import os
+import logging
+import json
+import time
+import asyncio
+import httpx
+import requests
+from pathlib import Path
+from typing import Optional
+
+log = logging.getLogger("eeclient")
+
+
+class SepalCredentialMixin:
+    def __init__(self, sepal_headers: Optional[SepalHeaders] = None):
+        log.debug("Initializing SepalCredentialMixin")
+
+        self.max_retries = 3
+        self._credentials = None
+        self.auth_mode = "sepal" if sepal_headers else "file"
+
+        if sepal_headers:
+            self._init_sepal_mode(sepal_headers)
+        else:
+            self._init_file_mode()
+
+        self.logger = logging.getLogger(f"eeclient.{self.user}")
+
+        # For backward compatibility (some code might expect this attribute)
+        self._service = None
+
+    def _init_sepal_mode(self, sepal_headers: SepalHeaders):
+        """Initialize SEPAL authentication mode"""
+        self.sepal_host = os.getenv("SEPAL_HOST")
+        if not self.sepal_host:
+            raise ValueError("SEPAL_HOST environment variable not set")
+
+        self.sepal_headers = SepalHeaders.model_validate(sepal_headers)
+        self.sepal_session_id = self.sepal_headers.cookies["SEPAL-SESSIONID"]
+        self.sepal_user_data = self.sepal_headers.sepal_user
+        self.user = self.sepal_user_data.username
+
+        self.sepal_api_download_url = (
+            f"https://{self.sepal_host}/api/user-files/download/"
+            "?path=%2F.config%2Fearthengine%2Fcredentials"
+        )
+        self.verify_ssl = not (
+            self.sepal_host == "host.docker.internal"
+            or self.sepal_host == "danielg.sepal.io"
+        )
+
+        self._google_tokens = self.sepal_user_data.google_tokens
+        if self._google_tokens:
+            self._credentials = self._google_tokens
+            self.access_token = self._google_tokens.access_token
+            self.project_id = self._google_tokens.project_id
+            self.expiry_date = self._google_tokens.access_token_expiry_date
+        else:
+            self.access_token = None
+            self.project_id = None
+            self.expiry_date = 0
+
+    def _init_file_mode(self):
+        """Initialize file-based authentication mode"""
+        home_path = Path.home()
+        credentials_file = (
+            ".config/earthengine/credentials"
+            if "sepal-user" in home_path.name
+            else ".config/earthengine/sepal_credentials"
+        )
+        self.credentials_path = home_path / credentials_file
+        self.user = "local_user"
+
+        # No SEPAL session info for file-based credentials
+        self.sepal_session_id = None
+        self.sepal_host = None
+        self.sepal_api_download_url = None
+        self.verify_ssl = True
+
+        # Load initial credentials
+        self._load_credentials_from_file()
+
+    def _load_credentials_from_file(self):
+        """Load credentials from file and update internal state"""
+        if not self.credentials_path.exists():
+            raise ValueError(f"Credentials file not found at {self.credentials_path}")
+
+        try:
+            credentials_data = json.loads(self.credentials_path.read_text())
+            self._credentials = GoogleTokens.model_validate(credentials_data)
+            self.access_token = self._credentials.access_token
+            self.project_id = self._credentials.project_id
+            self.expiry_date = self._credentials.access_token_expiry_date
+
+            if not self.access_token:
+                raise ValueError("No access token available in credentials file")
+
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON in credentials file: {e}")
+        except Exception as e:
+            raise ValueError(f"Error loading credentials from file: {e}")
+
+    def is_expired(self) -> bool:
+        """Returns if a token is about to expire"""
+        return (self.expiry_date / 1000) - time.time() < 60
+
+    def needs_credentials_refresh(self) -> bool:
+        """Returns if credentials need to be refreshed (missing or expired)"""
+        return not self._credentials or self.is_expired()
+
+    async def set_credentials(self) -> None:
+        """
+        Refresh credentials based on the authentication mode.
+        """
+        if self.auth_mode == "sepal":
+            await self._refresh_credentials_from_sepal()
+        else:
+            await self._refresh_credentials_from_file()
+
+    async def _refresh_credentials_from_sepal(self) -> None:
+        """Refresh credentials via SEPAL API"""
+        if not self.sepal_session_id or not self.sepal_api_download_url:
+            raise ValueError("SEPAL session information not available")
+
+        self.logger.debug(
+            "Token is expired or about to expire; "
+            "attempting to refresh credentials from SEPAL."
+        )
+        attempt = 0
+        credentials_url = self.sepal_api_download_url
+        last_status = None
+
+        # Prepare cookies for authentication
+        sepal_cookies = httpx.Cookies()
+        sepal_cookies.set("SEPAL-SESSIONID", self.sepal_session_id)
+
+        while attempt < self.max_retries:
+            attempt += 1
+            try:
+                async with httpx.AsyncClient(
+                    cookies=sepal_cookies,
+                    verify=self.verify_ssl,
+                    limits=httpx.Limits(
+                        max_connections=100, max_keepalive_connections=50
+                    ),
+                ) as client:
+                    self.logger.debug(
+                        f"Attempt {attempt} to refresh credentials from SEPAL."
+                    )
+                    response = await client.get(credentials_url)
+
+                last_status = response.status_code
+
+                if response.status_code == 200:
+                    self._credentials = GoogleTokens.model_validate(response.json())
+                    self.expiry_date = self._credentials.access_token_expiry_date
+                    self.access_token = self._credentials.access_token
+                    # Don't override project_id if enforce_project_id is set
+                    if not hasattr(self, "enforce_project_id") or not getattr(
+                        self, "enforce_project_id", False
+                    ):
+                        self.project_id = self._credentials.project_id
+                    self.logger.debug(
+                        f"Successfully refreshed credentials from SEPAL. "
+                        f"Project: {self.project_id}"
+                    )
+                    return
+                else:
+                    self.logger.debug(
+                        f"Attempt {attempt}/{self.max_retries} failed with "
+                        f"status code: {response.status_code}."
+                    )
+            except Exception as e:
+                self.logger.error(
+                    f"Attempt {attempt}/{self.max_retries} "
+                    f"encountered an exception: {e}"
+                )
+            await asyncio.sleep(2**attempt)  # Exponential backoff
+
+        raise ValueError(
+            f"Failed to retrieve credentials from SEPAL after "
+            f"{self.max_retries} attempts, last status code: {last_status}"
+        )
+
+    async def _refresh_credentials_from_file(self) -> None:
+        """Refresh credentials by re-reading from file"""
+        self.logger.debug(
+            "Token is expired or about to expire; "
+            "attempting to refresh credentials from file."
+        )
+        attempt = 0
+
+        while attempt < self.max_retries:
+            attempt += 1
+            try:
+                self.logger.debug(
+                    f"Attempt {attempt} to refresh credentials from file."
+                )
+
+                # Re-read credentials from file
+                self._load_credentials_from_file()
+
+                # Check if the new credentials are still expired
+                if not self.is_expired():
+                    self.logger.debug(
+                        f"Successfully refreshed credentials from file. "
+                        f"Project: {self.project_id}"
+                    )
+                    return
+                else:
+                    self.logger.debug(
+                        f"Attempt {attempt}/{self.max_retries}: "
+                        f"Credentials from file are still expired."
+                    )
+
+            except Exception as e:
+                self.logger.error(
+                    f"Attempt {attempt}/{self.max_retries} "
+                    f"encountered an exception while reading file: {e}"
+                )
+
+            # Wait before retrying (the file might be updated externally)
+            if attempt < self.max_retries:
+                wait_time = 2**attempt
+                self.logger.debug(f"Waiting {wait_time} seconds before retry...")
+                await asyncio.sleep(wait_time)
+
+        raise ValueError(
+            f"Failed to retrieve valid credentials from file after "
+            f"{self.max_retries} attempts. File may not be automatically "
+            f"updated or credentials are permanently expired."
+        )
+
+    def set_credentials_sync(self) -> None:
+        """
+        Refresh credentials synchronously based on the authentication mode.
+        """
+        if self.auth_mode == "sepal":
+            self._refresh_credentials_from_sepal_sync()
+        else:
+            self._refresh_credentials_from_file_sync()
+
+    def _refresh_credentials_from_sepal_sync(self) -> None:
+        """Refresh credentials via SEPAL API synchronously"""
+        if not self.sepal_session_id or not self.sepal_api_download_url:
+            raise ValueError("SEPAL session information not available")
+
+        self.logger.debug(
+            "Token is expired or about to expire; "
+            "attempting to refresh credentials from SEPAL (sync)."
+        )
+        attempt = 0
+        credentials_url = self.sepal_api_download_url
+        last_status = None
+
+        # Prepare session with cookies for authentication
+        session = requests.Session()
+        session.cookies.set("SEPAL-SESSIONID", self.sepal_session_id)
+        session.verify = self.verify_ssl
+
+        while attempt < self.max_retries:
+            attempt += 1
+            try:
+                self.logger.debug(
+                    f"Attempt {attempt} to refresh credentials from SEPAL (sync)."
+                )
+                response = session.get(credentials_url)
+                last_status = response.status_code
+
+                if response.status_code == 200:
+                    self._credentials = GoogleTokens.model_validate(response.json())
+                    self.expiry_date = self._credentials.access_token_expiry_date
+                    self.access_token = self._credentials.access_token
+                    # Don't override project_id if enforce_project_id is set
+                    if not hasattr(self, "enforce_project_id") or not getattr(
+                        self, "enforce_project_id", False
+                    ):
+                        self.project_id = self._credentials.project_id
+                    self.logger.debug(
+                        f"Successfully refreshed credentials from SEPAL (sync). "
+                        f"Project: {self.project_id}"
+                    )
+                    return
+                else:
+                    self.logger.debug(
+                        f"Attempt {attempt}/{self.max_retries} failed with "
+                        f"status code: {response.status_code}."
+                    )
+            except Exception as e:
+                self.logger.error(
+                    f"Attempt {attempt}/{self.max_retries} "
+                    f"encountered an exception: {e}"
+                )
+
+            # Wait before retrying (exponential backoff)
+            if attempt < self.max_retries:
+                wait_time = 2**attempt
+                self.logger.debug(f"Waiting {wait_time} seconds before retry...")
+                time.sleep(wait_time)
+
+        session.close()
+        raise ValueError(
+            f"Failed to retrieve credentials from SEPAL after "
+            f"{self.max_retries} attempts, last status code: {last_status}"
+        )
+
+    def _refresh_credentials_from_file_sync(self) -> None:
+        """Refresh credentials by re-reading from file synchronously"""
+        self.logger.debug(
+            "Token is expired or about to expire; "
+            "attempting to refresh credentials from file (sync)."
+        )
+        attempt = 0
+
+        while attempt < self.max_retries:
+            attempt += 1
+            try:
+                self.logger.debug(
+                    f"Attempt {attempt} to refresh credentials from file (sync)."
+                )
+
+                # Re-read credentials from file
+                self._load_credentials_from_file()
+
+                # Check if the new credentials are still expired
+                if not self.is_expired():
+                    self.logger.debug(
+                        f"Successfully refreshed credentials from file (sync). "
+                        f"Project: {self.project_id}"
+                    )
+                    return
+                else:
+                    self.logger.debug(
+                        f"Attempt {attempt}/{self.max_retries}: "
+                        f"Credentials from file are still expired."
+                    )
+
+            except Exception as e:
+                self.logger.error(
+                    f"Attempt {attempt}/{self.max_retries} "
+                    f"encountered an exception while reading file: {e}"
+                )
+
+            # Wait before retrying (the file might be updated externally)
+            if attempt < self.max_retries:
+                wait_time = 2**attempt
+                self.logger.debug(f"Waiting {wait_time} seconds before retry...")
+                time.sleep(wait_time)
+
+        raise ValueError(
+            f"Failed to retrieve valid credentials from file after "
+            f"{self.max_retries} attempts. File may not be automatically "
+            f"updated or credentials are permanently expired."
+        )

{ee_client-2.0.3 → ee_client-2.2.0}/eeclient/tasks.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from eeclient.client import EESession
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, computed_field
 from typing import List, Optional, Any
 from datetime import datetime
 
@@ -31,7 +31,7 @@ class Stage(CamelCaseModel):
 
 class TaskMetadata(CamelCaseModel):
     type_info: str = Field(alias="@type")
-    state: str
+    state: Optional[str] = None
     description: str
     priority: int
     create_time: datetime
@@ -40,7 +40,7 @@ class TaskMetadata(CamelCaseModel):
     end_time: Optional[datetime] = None
     type: str
     destination_uris: Optional[List[str]] = None
-    attempt: int
+    attempt: Optional[int] = None
     progress: Optional[float] = None
     stages: Optional[List[Stage]] = None
     batch_eecu_usage_seconds: Optional[float] = None
@@ -55,9 +55,20 @@ class Task(CamelCaseModel):
     metadata: TaskMetadata
     done: Optional[bool] = None
     response: Optional[Response] = None
-    # Add error field which might be present instead of response
     error: Optional[Any] = None
 
+    @computed_field
+    @property
+    def id(self) -> str:
+        """Extract the task ID from the name field.
+
+        The name field has format: 'projects/{project}/operations/{task_id}'
+        This property extracts just the {task_id} part.
+        """
+        if "/operations/" in self.name:
+            return self.name.split("/operations/")[-1]
+        return self.name
+
 
 class TasksResponse(CamelCaseModel):
     operations: List[Task]
@@ -79,7 +90,7 @@ async def get_tasks_async(client: "EESession") -> TasksResponse:
     return operations_response
 
 
-async def get_task_async(client: "EESession", task_id: str):
+async def get_task_async(client: "EESession", task_id: str) -> Optional[Task]:
     """Search for the described task in the user Task list return None if
     nothing is found.
 

{ee_client-2.0.3 → ee_client-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ee-client"
-version = "2.0.3"
+version = "2.2.0"
 description = "extends the capabilities of the earthengine-api by providing custom session management and client interactions"
 readme = { file = "README.rst",  content-type = "text/x-rst" }
 authors = [
@@ -66,7 +66,7 @@ branch = true
 [tool.commitizen]
 tag_format = "v$major.$minor.$patch$prerelease"
 update_changelog_on_bump = false
-version = "2.0.3"
+version = "2.2.0"
 version_files = [
     "pyproject.toml:version",
     "eeclient/__init__.py:__version__",