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

ee/tests/ee_test.py

@@ -8,6 +8,7 @@ from google.oauth2 import credentials
 
 import unittest
 import ee
+from ee import _state
 from ee import apitestcase
 
 
@@ -18,7 +19,7 @@ class EETestCase(apitestcase.ApiTestCase):
     ee.Reset()
     ee.data._install_cloud_api_resource = lambda: None
 
-  def testInitialization(self):
+  def test_initialization(self):
     """Verifies library initialization."""
 
     def MockAlgorithms():
@@ -27,33 +28,50 @@ class EETestCase(apitestcase.ApiTestCase):
     ee.data.getAlgorithms = MockAlgorithms
 
     # Verify that the base state is uninitialized.
-    self.assertFalse(ee.data._initialized)
-    self.assertIsNone(ee.data._api_base_url)
+    state = _state.get_state()
+    self.assertFalse(state.initialized)
+    self.assertIsNone(state.credentials)
+    self.assertIsNone(state.api_base_url)
+    self.assertIsNone(state.tile_base_url)
+    self.assertIsNone(state.cloud_api_base_url)
+    self.assertIsNone(state.cloud_api_key)
+    self.assertIsNone(state.requests_session)
+    self.assertIsNone(state.cloud_api_resource)
+    self.assertIsNone(state.cloud_api_resource_raw)
+    self.assertEqual(state.cloud_api_user_project, 'earthengine-legacy')
+    self.assertIsNone(state.cloud_api_client_version)
+    self.assertIsNone(state.http_transport)
+    self.assertEqual(state.deadline_ms, 0)
+    self.assertEqual(state.max_retries, 5)
+    self.assertIsNone(state.user_agent)
     self.assertEqual(ee.ApiFunction._api, {})
     self.assertFalse(ee.Image._initialized)
 
     # Verify that ee.Initialize() sets the URL and initializes classes.
     ee.Initialize(None, 'foo', project='my-project')
-    self.assertTrue(ee.data._initialized)
-    self.assertEqual(ee.data._api_base_url, 'foo/api')
-    self.assertEqual(ee.data._cloud_api_user_project, 'my-project')
+    state = _state.get_state()
+    self.assertTrue(state.initialized)
+    self.assertEqual(state.api_base_url, 'foo/api')
+    self.assertEqual(state.cloud_api_user_project, 'my-project')
     self.assertEqual(ee.ApiFunction._api, {})
     self.assertTrue(ee.Image._initialized)
 
     # Verify that ee.Initialize() without a URL does not override custom URLs.
     ee.Initialize(None, project='my-project')
-    self.assertTrue(ee.data._initialized)
-    self.assertEqual(ee.data._api_base_url, 'foo/api')
+    state = _state.get_state()
+    self.assertTrue(state.initialized)
+    self.assertEqual(state.api_base_url, 'foo/api')
 
     # Verify that ee.Reset() reverts everything to the base state.
     ee.Reset()
-    self.assertFalse(ee.data._initialized)
-    self.assertIsNone(ee.data._api_base_url)
-    self.assertIsNone(ee.data._cloud_api_user_project)
+    state = _state.get_state()
+    self.assertFalse(state.initialized)
+    self.assertIsNone(state.api_base_url)
+    self.assertEqual(state.cloud_api_user_project, 'earthengine-legacy')
     self.assertEqual(ee.ApiFunction._api, {})
     self.assertFalse(ee.Image._initialized)
 
-  def testProjectInitialization(self):
+  def test_project_initialization(self):
     """Verifies that we can fetch the client project from many locations.
 
     This also exercises the logic in data.get_persistent_credentials.
@@ -118,7 +136,7 @@ class EETestCase(apitestcase.ApiTestCase):
         ee.Initialize()
       self.assertEqual(6, inits.call_count)
 
-  def testCallAndApply(self):
+  def test_call_and_apply(self):
     """Verifies library initialization."""
 
     # Use a custom set of known functions.
@@ -174,7 +192,7 @@ class EETestCase(apitestcase.ApiTestCase):
     called_with_null = ee.call('fakeFunction', None, 1)
     self.assertIsNone(called_with_null.args['image1'])
 
-  def testDynamicClasses(self):
+  def test_dynamic_classes(self):
     """Verifies dynamic class initialization."""
 
     # Use a custom set of known functions.
@@ -280,7 +298,7 @@ class EETestCase(apitestcase.ApiTestCase):
         ee.EEException, 'Unknown algorithm: Reducer.moo'):
       ee.call('fakeFunction', 'moo')
 
-  def testDynamicConstructor(self):
+  def test_dynamic_constructor(self):
     # Test the behavior of the dynamic class constructor.
 
     # Use a custom set of known functions for classes Foo and Bar.
@@ -389,7 +407,7 @@ class EETestCase(apitestcase.ApiTestCase):
     with self.assertRaisesRegex(ee.EEException, 'Must be a ComputedObject'):
       ee.Bar(1)
 
-  def testDynamicConstructorCasting(self):
+  def test_dynamic_constructor_casting(self):
     """Test the behavior of casting with dynamic classes."""
     self.InitializeApi()
     result = ee.Geometry.Rectangle(1, 1, 2, 2).bounds(0, 'EPSG:4326')
@@ -398,7 +416,7 @@ class EETestCase(apitestcase.ApiTestCase):
             ee.ErrorMargin(0), ee.Projection('EPSG:4326')))
     self.assertEqual(expected, result)
 
-  def testPromotion(self):
+  def test_promotion(self):
     """Verifies object promotion rules."""
     self.InitializeApi()
 
@@ -415,7 +433,7 @@ class EETestCase(apitestcase.ApiTestCase):
     self.assertIsInstance(ee._Promote(untyped, 'Element'), ee.Element)
     self.assertEqual('foo', ee._Promote(untyped, 'Element').varName)
 
-  def testUnboundMethods(self):
+  def test_unbound_methods(self):
     """Verifies unbound method attachment to ee.Algorithms."""
 
     # Use a custom set of known functions.
@@ -458,11 +476,11 @@ class EETestCase(apitestcase.ApiTestCase):
     self.assertEqual(ee.call('Foo.bar'), ee.Algorithms.Foo.bar())
     self.assertNotEqual(ee.Algorithms.Foo.bar(), ee.Algorithms.last())
 
-  def testNonAsciiDocumentation(self):
+  def test_non_ascii_documentation(self):
     """Verifies that non-ASCII characters in documentation work."""
-    foo = u'\uFB00\u00F6\u01EB'
-    bar = u'b\u00E4r'
-    baz = u'b\u00E2\u00DF'
+    foo = '\uFB00\u00F6\u01EB'
+    bar = 'b\u00E4r'
+    baz = 'b\u00E2\u00DF'
 
     def MockAlgorithms():
       return {

ee/tests/element_test.py

@@ -10,7 +10,7 @@ from ee import apitestcase
 
 class ElementTestCase(apitestcase.ApiTestCase):
 
-  def testSet(self):
+  def test_set(self):
     """Verifies Element.set() keyword argument interpretation."""
     image = ee.Image(1)
 
@@ -48,7 +48,7 @@ class ElementTestCase(apitestcase.ApiTestCase):
     CheckMultiProperties(image.set(computed_arg))
     CheckMultiProperties(image.set({'properties': computed_arg}))
 
-  def testInitOptParams(self):
+  def test_init_opt_params(self):
     result = ee.Element(func=None, args=None, opt_varName='test').serialize()
     self.assertIn('"0": {"argumentReference": "test"}', result)
 

ee/tests/errormargin_test.py

@@ -26,7 +26,7 @@ class ErrorMarginTest(apitestcase.ApiTestCase):
     self.assertEqual(errormargin_func, errormargin.func)
 
     self.assertFalse(errormargin.isVariable())
-    self.assertEqual(set([UNIT, VALUE]), set(errormargin.args))
+    self.assertEqual({UNIT, VALUE}, set(errormargin.args))
     expected_unit = {
         'result': '0',
         'values': {'0': {'constantValue': 'projected'}},

ee/tests/feature_test.py

@@ -2,7 +2,7 @@
 """Test for the ee.feature module."""
 
 import json
-from typing import Any, Dict
+from typing import Any
 from unittest import mock
 
 import unittest
@@ -40,7 +40,7 @@ FEATURE_A_GRAPH = {
 }
 
 
-def right_maxerror_proj(function_name: str) -> Dict[str, Any]:
+def right_maxerror_proj(function_name: str) -> dict[str, Any]:
   return {
       'result': '0',
       'values': {
@@ -61,8 +61,8 @@ def right_maxerror_proj(function_name: str) -> Dict[str, Any]:
 
 
 def make_expression_graph(
-    function_invocation_value: Dict[str, Any],
-) -> Dict[str, Any]:
+    function_invocation_value: dict[str, Any],
+) -> dict[str, Any]:
   return {
       'result': '0',
       'values': {'0': {'functionInvocationValue': function_invocation_value}},
@@ -71,7 +71,7 @@ def make_expression_graph(
 
 class FeatureTest(apitestcase.ApiTestCase):
 
-  def testConstructors(self):
+  def test_constructors(self):
     """Verifies that constructors understand valid parameters."""
     point = ee.Geometry.Point(1, 2)
     from_geometry = ee.Feature(point)
@@ -121,7 +121,7 @@ class FeatureTest(apitestcase.ApiTestCase):
         'system:index': 'bar'
     }, from_geo_json_feature.args['metadata'])
 
-  def testGetMap(self):
+  def test_get_map(self):
     """Verifies that getMap() uses Collection.draw to rasterize Features."""
     feature = ee.Feature(None)
     mapid = feature.getMapId({'color': 'ABCDEF'})
@@ -132,7 +132,7 @@ class FeatureTest(apitestcase.ApiTestCase):
     self.assertEqual('fakeMapId', mapid['mapid'])
     self.assertEqual(manual.serialize(), mapid['image'].serialize())
 
-  def testInitOptParams(self):
+  def test_init_opt_params(self):
     result = ee.Feature(
         geom=ee.Geometry.Point(1, 2), opt_properties=dict(prop='a')
     ).serialize()
@@ -328,7 +328,7 @@ class FeatureTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_cutLines(self):
+  def test_cut_lines(self):
     expect = make_expression_graph({
         'arguments': {
             'feature': FEATURE_NONE_GRAPH,
@@ -546,7 +546,7 @@ class FeatureTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_setGeometry(self):
+  def test_set_geometry(self):
     expect = make_expression_graph({
         'arguments': {
             'feature': FEATURE_NONE_GRAPH,
@@ -646,7 +646,7 @@ class FeatureTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_withinDistance(self):
+  def test_within_distance(self):
     expect = {
         'result': '0',
         'values': {

ee/tests/featurecollection_test.py

@@ -2,7 +2,7 @@
 """Test for the ee.featurecollection module."""
 
 import json
-from typing import Any, Dict
+from typing import Any
 from unittest import mock
 
 import unittest
@@ -12,8 +12,8 @@ from ee import apitestcase
 
 
 def make_expression_graph(
-    function_invocation_value: Dict[str, Any],
-) -> Dict[str, Any]:
+    function_invocation_value: dict[str, Any],
+) -> dict[str, Any]:
   return {
       'result': '0',
       'values': {'0': {'functionInvocationValue': function_invocation_value}},

ee/tests/filter_test.py

@@ -3,7 +3,7 @@
 
 import datetime
 import json
-from typing import Any, Dict
+from typing import Any
 
 import unittest
 import ee
@@ -11,15 +11,15 @@ from ee import apitestcase
 
 
 def make_expression_graph(
-    function_invocation_value: Dict[str, Any],
-) -> Dict[str, Any]:
+    function_invocation_value: dict[str, Any],
+) -> dict[str, Any]:
   return {
       'result': '0',
       'values': {'0': {'functionInvocationValue': function_invocation_value}},
   }
 
 
-def max_error_expression(max_error: float) -> Dict[str, Any]:
+def max_error_expression(max_error: float) -> dict[str, Any]:
   return {
       'functionInvocationValue': {
           'functionName': 'ErrorMargin',

ee/tests/function_test.py

@@ -34,7 +34,7 @@ Args:
 
 class FunctionTest(unittest.TestCase):
 
-  def testNameArgs(self):
+  def test_name_args(self):
     """Verifies that Functions can convert positional to named arguments."""
     self.assertEqual({}, TEST_FUNC.nameArgs([]))
     self.assertEqual({'a': 42}, TEST_FUNC.nameArgs([42]))
@@ -44,7 +44,7 @@ class FunctionTest(unittest.TestCase):
     self.assertRaisesRegex(ee.EEException, 'Too many', TEST_FUNC.nameArgs,
                            [1, 2, 3])
 
-  def testPromoteArgs(self):
+  def test_promote_args(self):
     """Verifies that Functions can promote and verify their arguments."""
     old_promoter = ee.Function._promoter
     ee.Function._registerPromoter(lambda obj, type_name: [type_name, obj])
@@ -75,7 +75,7 @@ class FunctionTest(unittest.TestCase):
     # Clean up.
     ee.Function._registerPromoter(old_promoter)
 
-  def testCall(self):
+  def test_call(self):
     """Verifies the full function invocation flow."""
     old_promoter = ee.Function._promoter
     ee.Function._registerPromoter(lambda obj, type_name: [type_name, obj])
@@ -91,11 +91,11 @@ class FunctionTest(unittest.TestCase):
     # Clean up.
     ee.Function._registerPromoter(old_promoter)
 
-  def testToString(self):
+  def test_to_string(self):
     """Verifies function docstring generation."""
     self.assertEqual(EXPECTED_DOC, str(TEST_FUNC))
 
-  def testArgumentFailureMessage(self):
+  def test_argument_failure_message(self):
     """Verifies properly formed function error message generation."""
     self.assertRaisesRegex(
         ee.EEException,

ee/tests/geometry_point_test.py

@@ -2,7 +2,7 @@
 """Test for the ee.geometry module Point methods."""
 
 import json
-from typing import Any, Dict
+from typing import Any
 from unittest import mock
 
 import unittest
@@ -45,8 +45,8 @@ PROJ = {
 
 
 def make_expression_graph_geom(
-    function_name: str, args: Dict[str, Any]
-) -> Dict[str, Any]:
+    function_name: str, args: dict[str, Any]
+) -> dict[str, Any]:
   return {
       'result': '0',
       'values': {