earthengine-api 1.6.11rc0__py3-none-any.whl → 1.6.12__py3-none-any.whl

ee/tests/ee_number_test.py

@@ -21,7 +21,7 @@ def make_expression_graph(
 
 class NumberTest(apitestcase.ApiTestCase):
 
-  def testNumber(self):
+  def test_number(self):
     """Verifies basic behavior of ee.Number."""
     num = ee.Number(1)
     self.assertEqual(1, num.encode())
@@ -34,7 +34,7 @@ class NumberTest(apitestcase.ApiTestCase):
         'right': ee.Number(2)
     }, computed.args)
 
-  def testInternals(self):
+  def test_internals(self):
     """Test eq(), ne() and hash()."""
     a = ee.Number(1)
     b = ee.Number(2.1)
@@ -46,6 +46,12 @@ class NumberTest(apitestcase.ApiTestCase):
     self.assertNotEqual(b, c)
     self.assertNotEqual(hash(a), hash(b))
 
+  def test_init_invalid_arg(self):
+    with self.assertRaisesRegex(
+        ee.EEException, 'Invalid argument specified for ee.Number'
+    ):
+      ee.Number('not a number')  # pytype: disable=wrong-arg-types
+
   def test_abs(self):
     expect = make_expression_graph({
         'arguments': {
@@ -139,7 +145,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_bitCount(self):
+  def test_bit_count(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -150,7 +156,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_bitwiseAnd(self):
+  def test_bitwise_and(self):
     expect = make_expression_graph({
         'arguments': {
             'left': {'constantValue': 1},
@@ -166,7 +172,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_bitwiseNot(self):
+  def test_bitwise_not(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -177,7 +183,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_bitwiseOr(self):
+  def test_bitwise_or(self):
     expect = make_expression_graph({
         'arguments': {
             'left': {'constantValue': 1},
@@ -193,7 +199,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_bitwiseXor(self):
+  def test_bitwise_xor(self):
     expect = make_expression_graph({
         'arguments': {
             'left': {'constantValue': 1},
@@ -346,7 +352,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_erfInv(self):
+  def test_erf_inv(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -368,7 +374,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_erfcInv(self):
+  def test_erfc_inv(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -406,7 +412,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_firstNonZero(self):
+  def test_first_non_zero(self):
     expect = make_expression_graph({
         'arguments': {
             'left': {'constantValue': 1},
@@ -601,7 +607,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_leftShift(self):
+  def test_left_shift(self):
     expect = make_expression_graph({
         'arguments': {
             'left': {'constantValue': 1},
@@ -807,7 +813,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_rightShift(self):
+  def test_right_shift(self):
     expect = make_expression_graph({
         'arguments': {
             'left': {'constantValue': 1},
@@ -927,7 +933,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toByte(self):
+  def test_to_byte(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -938,7 +944,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toDouble(self):
+  def test_to_double(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -949,7 +955,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toFloat(self):
+  def test_to_float(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -960,7 +966,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toInt(self):
+  def test_to_int(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -971,7 +977,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toInt16(self):
+  def test_to_int16(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -982,7 +988,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toInt32(self):
+  def test_to_int32(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -993,7 +999,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toInt64(self):
+  def test_to_int64(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -1004,7 +1010,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toInt8(self):
+  def test_to_int8(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -1015,7 +1021,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toLong(self):
+  def test_to_long(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -1026,7 +1032,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toShort(self):
+  def test_to_short(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -1037,7 +1043,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toUint16(self):
+  def test_to_uint16(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -1048,7 +1054,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toUint32(self):
+  def test_to_uint32(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -1059,7 +1065,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toUint8(self):
+  def test_to_uint8(self):
     expect = make_expression_graph({
         'arguments': {
             'input': {'constantValue': 1},
@@ -1114,7 +1120,7 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_unitScale(self):
+  def test_unit_scale(self):
     expect = make_expression_graph({
         'arguments': {
             'number': {'constantValue': 1},

ee/tests/ee_string_test.py

@@ -107,6 +107,14 @@ class StringTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
+    expect = make_expression_graph({
+        'arguments': {'object': {'constantValue': [1]}},
+        'functionName': 'String.encodeJSON',
+    })
+    expression = ee.String.encodeJSON([1])
+    result = json.loads(expression.serialize())
+    self.assertEqual(expect, result)
+
   def test_equals(self):
     expect = make_expression_graph({
         'arguments': {

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.assertEqual(ee.data._cloud_api_user_project, 'earthengine-legacy')
+    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,7 +476,7 @@ 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 = '\uFB00\u00F6\u01EB'
     bar = 'b\u00E4r'

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/feature_test.py

@@ -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/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,