earthengine-api 1.5.13rc0__py3-none-any.whl → 1.7.4__py3-none-any.whl

ee/apifunction.py

@@ -1,7 +1,7 @@
 """A class for representing built-in EE API Function.
 
 Earth Engine can dynamically produce a JSON array listing the
-algorithms available to the user.  Each item in the dictionary identifies
+algorithms available to the user. Each item in the dictionary identifies
 the name and return type of the algorithm, the name and type of its
 arguments, whether they're required or optional, default values and docs
 for each argument and the algorithms as a whole.
@@ -18,7 +18,7 @@ from __future__ import annotations
 import copy
 import keyword
 import re
-from typing import Any, Dict, Optional, Set, Type
+from typing import Any
 
 from ee import _utils
 from ee import computedobject
@@ -31,17 +31,17 @@ from ee import function
 
 class ApiFunction(function.Function):
   """An object representing an EE API Function."""
-  _signature: Dict[str, Any]
+  _signature: dict[str, Any]
 
   # A dictionary of functions defined by the API server.
-  _api: Dict[str, ApiFunction] = {}
+  _api: dict[str, ApiFunction] = {}
 
   # A set of algorithm names containing all algorithms that have been bound to
   # a function so far using importApi().
-  _bound_signatures: Set[str] = set()
+  _bound_signatures: set[str] = set()
 
   @_utils.accept_opt_prefix('opt_signature')
-  def __init__(self, name: str, signature: Optional[Dict[str, Any]] = None):
+  def __init__(self, name: str, signature: dict[str, Any] | None = None):
     """Creates a function defined by the EE API.
 
     Args:
@@ -60,7 +60,7 @@ class ApiFunction(function.Function):
     return (isinstance(other, ApiFunction) and
             self.getSignature() == other.getSignature())
 
-  # For Python 3, __hash__ is needed because __eq__ is defined.
+  # __hash__ is needed because __eq__ is defined.
   # See https://docs.python.org/3/reference/datamodel.html#object.__hash__
   def __hash__(self) -> int:
     return hash(computedobject.ComputedObject.freeze(self.getSignature()))
@@ -84,7 +84,7 @@ class ApiFunction(function.Function):
     return cls.lookup(name).call(*args, **kwargs)
 
   @classmethod
-  def apply_(cls, name: str, named_args: Dict[str, Any]) -> Any:
+  def apply_(cls, name: str, named_args: dict[str, Any]) -> Any:
     """Call a named API function with a dictionary of named arguments.
 
     Args:
@@ -101,27 +101,29 @@ class ApiFunction(function.Function):
     del encoder  # Unused.
     return self._signature['name']
 
-  def encode_cloud_invocation(self, encoder: Any) -> Dict[str, Any]:
+  def encode_cloud_invocation(self, encoder: Any) -> dict[str, Any]:
     del encoder  # Unused.
     return {'functionName': self._signature['name']}
 
-  def getSignature(self) -> Dict[str, Any]:
+  def getSignature(self) -> dict[str, Any]:
     """Returns a description of the interface provided by this function."""
     return self._signature
 
   @classmethod
-  def allSignatures(cls) -> Dict[str, Dict[str, Any]]:
+  def allSignatures(cls) -> dict[str, dict[str, Any]]:
     """Returns a map from the name to signature for all API functions."""
     cls.initialize()
-    return dict([(name, func.getSignature())
-                 for name, func in cls._api.items()])
+    return {name: func.getSignature() for name, func in cls._api.items()}
 
   @classmethod
-  def unboundFunctions(cls) -> Dict[str, Any]:
+  def unboundFunctions(cls) -> dict[str, Any]:
     """Returns the functions that have not been bound using importApi() yet."""
     cls.initialize()
-    return dict([(name, func) for name, func in cls._api.items()
-                 if name not in cls._bound_signatures])
+    return {
+        name: func
+        for name, func in cls._api.items()
+        if name not in cls._bound_signatures
+    }
 
   # TODO(user): Any -> ApiFunction for the return type.
   @classmethod
@@ -142,7 +144,7 @@ class ApiFunction(function.Function):
     return result
 
   @classmethod
-  def lookupInternal(cls, name: str) -> Optional[ApiFunction]:
+  def lookupInternal(cls, name: str) -> ApiFunction | None:
     """Looks up an API function by name.
 
     Args:
@@ -181,7 +183,7 @@ class ApiFunction(function.Function):
       target: Any,
       prefix: str,
       type_name: str,
-      prepend: Optional[str] = None,
+      prepend: str | None = None,
   ) -> None:
     """Adds all API functions that begin with a given prefix to a target class.
 
@@ -248,7 +250,7 @@ class ApiFunction(function.Function):
         setattr(target, fname, bound_function)
 
   @staticmethod
-  def clearApi(target: Type[Any]) -> None:
+  def clearApi(target: type[Any]) -> None:
     """Removes all methods added by importApi() from a target class.
 
     Args:

ee/apitestcase.py

@@ -1,22 +1,25 @@
 """A TestCase that initializes the library with standard API methods."""
 
+from collections.abc import Iterable
 import contextlib
+import copy
 import json
 import os
-from typing import Any, Dict, Iterable, Optional
+from typing import Any
 
 from googleapiclient import discovery
 
 import unittest
 import ee
 from ee import _cloud_api_utils
+from ee import _state
 
 
 # Cached algorithms list
-_algorithms_cache: Optional[Dict[str, Any]] = None
+_algorithms_cache: dict[str, Any] | None = None
 
 
-def GetAlgorithms() -> Dict[str, Any]:
+def GetAlgorithms() -> dict[str, Any]:
   """Returns a static version of the ListAlgorithms call.
 
   After ApiTestCase.setUp is called, ee.data.getAlgorithms() is patched to use
@@ -37,10 +40,10 @@ def GetAlgorithms() -> Dict[str, Any]:
 
 class ApiTestCase(unittest.TestCase):
   """A TestCase that initializes the library with standard API methods."""
-  last_download_call: Optional[Any]
-  last_thumb_call: Optional[Any]
-  last_table_call: Optional[Any]
-  last_mapid_call: Optional[Any]
+  last_download_call: Any | None
+  last_thumb_call: Any | None
+  last_table_call: Any | None
+  last_mapid_call: Any | None
 
   def setUp(self):
     super().setUp()
@@ -52,13 +55,8 @@ class ApiTestCase(unittest.TestCase):
     self.old_get_download_id = ee.data.getDownloadId
     self.old_get_thumb_id = ee.data.getThumbId
     self.old_get_table_download_id = ee.data.getTableDownloadId
-    # pylint: disable=protected-access
-    self.old_install_cloud_api_resource = ee.data._install_cloud_api_resource
-    self.old_cloud_api_resource = ee.data._cloud_api_resource
-    self.old_cloud_api_resource_raw = ee.data._cloud_api_resource_raw
-    self.old_initialized = ee.data._initialized
+    # pylint: disable-next=protected-access
     self.old_fetch_data_catalog_stac = ee.deprecation._FetchDataCatalogStac
-    # pylint: enable=protected-access
     self.InitializeApi()
 
   def tearDown(self):
@@ -69,13 +67,9 @@ class ApiTestCase(unittest.TestCase):
     ee.data.getDownloadId = self.old_get_download_id
     ee.data.getThumbId = self.old_get_thumb_id
     ee.data.getTableDownloadId = self.old_get_table_download_id
-    # pylint: disable=protected-access
-    ee.data._install_cloud_api_resource = self.old_install_cloud_api_resource
-    ee.data._cloud_api_resource = self.old_cloud_api_resource
-    ee.data._cloud_api_resource_raw = self.old_cloud_api_resource_raw
-    ee.data._initialized = self.old_initialized
+    _state.reset_state()
+    # pylint: disable-next=protected-access
     ee.deprecation._FetchDataCatalogStac = self.old_fetch_data_catalog_stac
-    # pylint: enable=protected-access
 
   def InitializeApi(self):
     """Initializes the library with standard API methods.
@@ -102,30 +96,30 @@ class ApiTestCase(unittest.TestCase):
     ee.Initialize(None, '', project='my-project')
 
   # We are mocking the url here so the unit tests are happy.
-  def _MockMapId(self, params: Dict[str, Any]) -> Dict[str, str]:
+  def _MockMapId(self, params: dict[str, Any]) -> dict[str, str]:
     self.last_mapid_call = {'url': '/mapid', 'data': params}
     return {'mapid': 'fakeMapId', 'token': 'fakeToken'}
 
-  def _MockDownloadUrl(self, params: Dict[str, Any]) -> Dict[str, str]:
+  def _MockDownloadUrl(self, params: dict[str, Any]) -> dict[str, str]:
     self.last_download_call = {'url': '/download', 'data': params}
     return {'docid': '1', 'token': '2'}
 
   def _MockThumbUrl(
       self,
-      params: Dict[str, Any],
+      params: dict[str, Any],
       # pylint: disable-next=invalid-name
-      thumbType: Optional[str] = None,
-  ) -> Dict[str, str]:
+      thumbType: str | None = None,
+  ) -> dict[str, str]:
     del thumbType  # Unused.
     # Hang on to the call arguments.
     self.last_thumb_call = {'url': '/thumb', 'data': params}
     return {'thumbid': '3', 'token': '4'}
 
-  def _MockTableDownload(self, params: Dict[str, Any]) -> Dict[str, str]:
+  def _MockTableDownload(self, params: dict[str, Any]) -> dict[str, str]:
     self.last_table_call = {'url': '/table', 'data': params}
     return {'docid': '5', 'token': '6'}
 
-  def _MockFetchDataCatalogStac(self) -> Dict[str, Any]:
+  def _MockFetchDataCatalogStac(self) -> dict[str, Any]:
     return {}
 
 
@@ -147,27 +141,28 @@ def _GenerateCloudApiResource(mock_http: Any, raw: Any) -> discovery.Resource:
 
 @contextlib.contextmanager  # pytype: disable=wrong-arg-types
 def UsingCloudApi(
-    cloud_api_resource: Optional[Any] = None,
-    cloud_api_resource_raw: Optional[Any] = None,
-    mock_http: Optional[Any] = None,
+    cloud_api_resource: Any | None = None,
+    cloud_api_resource_raw: Any | None = None,
+    mock_http: Any | None = None,
 ) -> Iterable[Any]:  # pytype: disable=wrong-arg-types
   """Returns a context manager under which the Cloud API is enabled."""
-  old_cloud_api_resource = ee.data._cloud_api_resource  # pylint: disable=protected-access
-  old_cloud_api_resource_raw = ee.data._cloud_api_resource_raw  # pylint: disable=protected-access
-  old_initialized = ee.data._initialized  # pylint: disable=protected-access
+  # pylint: disable=protected-access
+  old_state = copy.copy(_state._state)
+  # pylint: enable=protected-access
   try:
     if cloud_api_resource is None:
       cloud_api_resource = _GenerateCloudApiResource(mock_http, False)
     if cloud_api_resource_raw is None:
       cloud_api_resource_raw = _GenerateCloudApiResource(mock_http, True)
-    ee.data._cloud_api_resource = cloud_api_resource  # pylint: disable=protected-access
-    ee.data._cloud_api_resource_raw = cloud_api_resource_raw  # pylint: disable=protected-access
-    ee.data._initialized = True  # pylint: disable=protected-access
+    state = _state.get_state()
+    state.cloud_api_resource = cloud_api_resource
+    state.cloud_api_resource_raw = cloud_api_resource_raw
+    state.initialized = True
     yield
   finally:
-    ee.data._cloud_api_resource = old_cloud_api_resource  # pylint: disable=protected-access
-    ee.data._cloud_api_resource_raw = old_cloud_api_resource_raw  # pylint: disable=protected-access
-    ee.data._initialized = old_initialized  # pylint: disable=protected-access
+    # pylint: disable=protected-access
+    _state._state = old_state
+    # pylint: enable=protected-access
 
 
 # A sample of encoded EE API JSON, used by SerializerTest and DeserializerTest.