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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ee-client
-Version: 2.1.0
+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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ee-client
-Version: 2.1.0
+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

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

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

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

@@ -1,14 +1,13 @@
 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
@@ -35,7 +34,11 @@ VERIFY_SSL = True
 
 
 class EESession(SepalCredentialMixin):
-    def __init__(self, sepal_headers: SepalHeaders, enforce_project_id: bool = True):
+    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
@@ -49,25 +52,20 @@ class EESession(SepalCredentialMixin):
         Raises:
             ValueError: If SEPAL_HOST environment variable is not set
         """
-        super().__init__(sepal_headers)
-
-        self.max_retries = 3
-        self._credentials = None
         self.enforce_project_id = enforce_project_id
+        super().__init__(sepal_headers)
 
         # Create user-specific logger
         self.logger = logging.getLogger(f"eeclient.{self.user}")
 
-        # Initialize credentials from the initial tokens
-        if self._google_tokens:
-            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.
@@ -83,11 +81,16 @@ class EESession(SepalCredentialMixin):
         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.
 
@@ -102,14 +105,6 @@ class EESession(SepalCredentialMixin):
             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 needs_credentials_refresh(self) -> bool:
-        """Returns if credentials need to be refreshed (missing or expired)"""
-        return not self._credentials or self.is_expired()
-
     def get_current_headers(self) -> GEEHeaders:
         """Get current headers without refreshing credentials"""
         if not self._credentials:
@@ -117,10 +112,17 @@ class EESession(SepalCredentialMixin):
 
         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)
@@ -149,68 +151,6 @@ class EESession(SepalCredentialMixin):
         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"],
@@ -343,7 +283,7 @@ class EESession(SepalCredentialMixin):
                 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.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.1.0 → ee_client-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ee-client"
-version = "2.1.0"
+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.1.0"
+version = "2.2.0"
 version_files = [
     "pyproject.toml:version",
     "eeclient/__init__.py:__version__",

ee_client-2.1.0/eeclient/sepal_credential_mixin.py

@@ -1,37 +0,0 @@
-from eeclient.models import SepalHeaders
-import os
-import logging
-
-log = logging.getLogger("eeclient")
-
-
-class SepalCredentialMixin:
-    def __init__(self, sepal_headers: SepalHeaders):
-        log.debug("Initializing GDriveInterface with SEPAL headers")
-        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.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