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

ee/tests/daterange_test.py

@@ -6,7 +6,7 @@ DateRange is currently 100% dynamically generated.
 
 import datetime
 import json
-from typing import Any, Dict
+from typing import Any
 
 import unittest
 import ee
@@ -22,15 +22,15 @@ DATERANGE = 'DateRange'
 
 
 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 daterange_function_expr(value: int) -> Dict[str, Any]:
+def daterange_function_expr(value: int) -> dict[str, Any]:
   return {
       'functionInvocationValue': {
           'functionName': 'DateRange',

ee/tests/deprecation_test.py

@@ -3,7 +3,7 @@
 
 import contextlib
 import datetime
-from typing import Any, Dict
+from typing import Any
 from unittest import mock
 import warnings
 
@@ -100,7 +100,8 @@ _EXPECTED_WARNINGS = {
         r'Attention required for date_and_learn_more! You are using a'
         r' deprecated asset.\nTo make sure your code keeps working, please'
         r' update'
-        r' it by July 1, 2024.\nLearn more: learn_more_url'
+        r' it by July 1, 2024.\nThis dataset has been superseded by'
+        r' replacement_id\n\nLearn more: learn_more_url'
     ),
     'date_only': (
         r'Attention required for date_only! You are using a deprecated asset.\n'
@@ -124,7 +125,8 @@ _EXPECTED_WARNINGS = {
         r'Attention required for learn_more_url_only! You are using a'
         r' deprecated asset.\nTo make sure your code keeps working, please'
         r' update'
-        r' it.\nLearn more: learn_more_url'
+        r' it.\nThis dataset has been superseded by replacement_id\n\nLearn'
+        r' more: learn_more_url'
     ),
 }
 
@@ -173,7 +175,7 @@ class DeprecationTest(apitestcase.ApiTestCase, parameterized.TestCase):
       yield
 
   # Overridden from apitestcase.ApiTestCase.
-  def _MockFetchDataCatalogStac(self) -> Dict[str, Any]:
+  def _MockFetchDataCatalogStac(self) -> dict[str, Any]:
     return _STAC_JSON
 
   def test_no_warnings_thrown(self):

ee/tests/deserializer_test.py

@@ -12,7 +12,7 @@ from ee import serializer
 
 class DeserializerTest(apitestcase.ApiTestCase):
 
-  def testLegacyRoundTrip(self):
+  def test_legacy_roundtrip(self):
     """Verifies a round trip of a comprehensive serialization case."""
     encoded = apitestcase.ENCODED_JSON_SAMPLE
     decoded = deserializer.decode(encoded)
@@ -25,7 +25,7 @@ class DeserializerTest(apitestcase.ApiTestCase):
         serializer.toJSON(cloud_decoded, for_cloud_api=True))
     self.assertEqual(cloud_encoded, cloud_re_encoded)
 
-  def testCloudRoundTrip(self):
+  def test_cloud_roundtrip(self):
     """Verifies a round trip of a comprehensive serialization case."""
     cloud_encoded = apitestcase.ENCODED_CLOUD_API_JSON_SAMPLE
     cloud_decoded = deserializer.decode(cloud_encoded)  # Supports both formats
@@ -38,7 +38,7 @@ class DeserializerTest(apitestcase.ApiTestCase):
     re_encoded = json.loads(serializer.toJSON(decoded, for_cloud_api=False))
     self.assertEqual(encoded, re_encoded)
 
-  def testCast(self):
+  def test_cast(self):
     """Verifies that decoding casts the result to the right class."""
     input_image = ee.Image(13).addBands(42)
     output = deserializer.fromJSON(serializer.toJSON(input_image))
@@ -47,7 +47,7 @@ class DeserializerTest(apitestcase.ApiTestCase):
         serializer.toJSON(input_image, for_cloud_api=True))
     self.assertIsInstance(cloud_output, ee.Image)
 
-  def testReuse(self):
+  def test_reuse(self):
     """Verifies that decoding results can be used and re-encoded."""
     input_image = ee.Image(13)
     output = deserializer.fromJSON(serializer.toJSON(input_image))
@@ -60,7 +60,7 @@ class DeserializerTest(apitestcase.ApiTestCase):
         cloud_output.addBands(42).serialize(),
         input_image.addBands(42).serialize())
 
-  def testImageExpression(self):
+  def test_image_expression(self):
     """Verifies that ee.Image.expression results can be re-encoded."""
     image = ee.Image(13)
     expression = image.expression('x', {'x': image})
@@ -69,5 +69,64 @@ class DeserializerTest(apitestcase.ApiTestCase):
     expression_re_encoded = serializer.toJSON(expression_decoded)
     self.assertEqual(expression_encoded, expression_re_encoded)
 
+  def test_unknown_value_ref(self):
+    """Verifies raising Unknown ValueRef in _decodeValue()."""
+    encoded = {
+        'type': 'CompoundValue',
+        'scope': [['key', {'type': 'ValueRef', 'value': 'bar'}]],
+    }
+    with self.assertRaisesRegex(
+        ee.EEException, "Unknown ValueRef: {'type': 'ValueRef', 'value': 'bar'}"
+    ):
+      deserializer.decode(encoded)
+
+  def test_duplicate_scope_key(self):
+    """Verifies raising duplicate scope key in decode()."""
+    encoded = {
+        'type': 'CompoundValue',
+        'scope': [['a', 1], ['a', 2]],
+        'value': 3,
+    }
+    with self.assertRaisesRegex(
+        ee.EEException, 'Duplicate scope key "a" in scope #1.'
+    ):
+      deserializer.decode(encoded)
+
+  def test_cannot_decode_object(self):
+    """Verifies raising EEException for non-dict objects in _decodeValue()."""
+    with self.assertRaisesRegex(
+        ee.EEException, r'Cannot decode object: \(1\+1j\)'
+    ):
+      deserializer.decode([1 + 1j])
+
+  def test_invalid_date_value(self):
+    """Verifies EEException for invalid date values in _decodeValue()."""
+    with self.assertRaisesRegex(
+        ee.EEException, r'Invalid date value: not-a-number'
+    ):
+      deserializer.decode({'type': 'Date', 'value': 'not-a-number'})
+
+  def test_invocation_of_custom_function(self):
+    """Verifies decoding of an Invocation of a CustomFunction."""
+    encoded = {
+        'type': 'Invocation',
+        'function': {
+            'type': 'Function',
+            'argumentNames': ['foo'],
+            'body': {'type': 'ArgumentRef', 'value': 'foo'},
+        },
+        'arguments': {'foo': 1},
+    }
+    decoded = deserializer.decode(encoded)
+    self.assertIsInstance(decoded, ee.ComputedObject)
+
+  def test_date_decode(self):
+    """Verifies decoding of a Date."""
+    encoded = {'type': 'Date', 'value': 1609459200000000}
+    decoded = deserializer.decode(encoded)
+    self.assertIsInstance(decoded, ee.Date)
+    self.assertEqual({'value': 1609459200000}, decoded.args)
+
+
 if __name__ == '__main__':
   unittest.main()

ee/tests/dictionary_test.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Test for the ee.dictionary module."""
 import json
-from typing import Any, Dict
+from typing import Any
 import unittest
 
 import unittest
@@ -10,8 +10,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}},
@@ -20,7 +20,7 @@ def make_expression_graph(
 
 class DictionaryTest(apitestcase.ApiTestCase):
 
-  def testDictionary(self):
+  def test_dictionary(self):
     """Verifies basic behavior of ee.Dictionary."""
     src = {'a': 1, 'b': 2, 'c': 'three'}
     dictionary = ee.Dictionary(src)
@@ -46,7 +46,7 @@ class DictionaryTest(apitestcase.ApiTestCase):
     for d in cons:
       self.assertIsInstance(d, ee.ComputedObject)
 
-  def testInternals(self):
+  def test_internals(self):
     """Test eq(), ne() and hash()."""
     a = ee.Dictionary({'one': 1})
     b = ee.Dictionary({'two': 2})
@@ -93,7 +93,7 @@ class DictionaryTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_fromLists(self):
+  def test_from_lists(self):
     expect = make_expression_graph({
         'arguments': {
             'keys': {'constantValue': ['a']},
@@ -126,7 +126,7 @@ class DictionaryTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_getArray(self):
+  def test_get_array(self):
     expect = make_expression_graph({
         'arguments': {
             'dictionary': {'constantValue': {'a': 1}},
@@ -142,7 +142,7 @@ class DictionaryTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_getGeometry(self):
+  def test_get_geometry(self):
     expect = make_expression_graph({
         'arguments': {
             'dictionary': {'constantValue': {'a': 1}},
@@ -158,7 +158,7 @@ class DictionaryTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_getNumber(self):
+  def test_get_number(self):
     expect = make_expression_graph({
         'arguments': {
             'dictionary': {'constantValue': {'a': 1}},
@@ -174,7 +174,7 @@ class DictionaryTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_getString(self):
+  def test_get_string(self):
     expect = make_expression_graph({
         'arguments': {
             'dictionary': {'constantValue': {'a': 1}},
@@ -292,7 +292,7 @@ class DictionaryTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toArray(self):
+  def test_to_array(self):
     expect = make_expression_graph({
         'arguments': {
             'dictionary': {'constantValue': {'a': 1}},
@@ -325,7 +325,7 @@ class DictionaryTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  def test_toImage(self):
+  def test_to_image(self):
     expect = make_expression_graph({
         'arguments': {
             'dictionary': {'constantValue': {'a': 1}},

ee/tests/ee_array_test.py

@@ -2,7 +2,7 @@
 """Tests for the ee.Array module."""
 
 import json
-from typing import Any, Dict
+from typing import Any
 
 import unittest
 import ee
@@ -24,8 +24,8 @@ ARRAY_TWO = {
 
 
 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/ee_date_test.py

@@ -3,7 +3,7 @@
 
 import datetime
 import json
-from typing import Any, Dict
+from typing import Any
 
 import unittest
 import ee
@@ -16,15 +16,15 @@ UTC = 'UTC'
 
 
 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 date_function_expr(value: int) -> Dict[str, Any]:
+def date_function_expr(value: int) -> dict[str, Any]:
   return {
       'functionInvocationValue': {
           'functionName': 'Date',

ee/tests/ee_list_test.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Test for the ee.list module."""
 import json
-from typing import Any, Dict
+from typing import Any
 
 import unittest
 import ee
@@ -9,8 +9,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/ee_number_test.py

@@ -2,7 +2,7 @@
 """Test for the ee.number module."""
 
 import json
-from typing import Any, Dict
+from typing import Any
 import unittest
 
 import unittest
@@ -11,8 +11,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}},
@@ -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},
@@ -390,6 +396,31 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
+  def test_expression(self):
+    expression = ee.Number.expression('1 + 2')
+    self.assertIsInstance(expression, ee.Number)
+    self.assertEqual(
+        ee.ApiFunction.lookup('Number.expression'), expression.func
+    )
+
+    expect = make_expression_graph({
+        'arguments': {'expression': {'constantValue': '1 + 2'}},
+        'functionName': 'Number.expression',
+    })
+    result = json.loads(expression.serialize())
+    self.assertEqual(expect, result)
+
+    expression_vars = ee.Number.expression('a + b', {'a': 1, 'b': 2})
+    expect_vars = make_expression_graph({
+        'arguments': {
+            'expression': {'constantValue': 'a + b'},
+            'vars': {'constantValue': {'a': 1, 'b': 2}},
+        },
+        'functionName': 'Number.expression',
+    })
+    result_vars = json.loads(expression_vars.serialize())
+    self.assertEqual(expect_vars, result_vars)
+
   def test_first(self):
     expect = make_expression_graph({
         'arguments': {
@@ -406,7 +437,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 +632,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},
@@ -789,7 +820,21 @@ class NumberTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  # TODO: test_parse.
+  def test_parse(self):
+    expect = make_expression_graph({
+        'arguments': {
+            'input': {'constantValue': '1'},
+            'radix': {'constantValue': 2},
+        },
+        'functionName': 'Number.parse',
+    })
+    expression = ee.Number.parse('1', 2)
+    result = json.loads(expression.serialize())
+    self.assertEqual(expect, result)
+
+    expression = ee.Number.parse(input='1', radix=2)
+    result = json.loads(expression.serialize())
+    self.assertEqual(expect, result)
 
   def test_pow(self):
     expect = make_expression_graph({
@@ -807,7 +852,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 +972,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 +983,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 +994,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 +1005,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 +1016,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 +1027,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 +1038,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 +1049,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 +1060,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 +1071,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 +1082,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 +1093,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 +1104,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 +1159,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

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Test for the ee.string module."""
 import json
-from typing import Any, Dict
+from typing import Any
 import unittest
 
 import unittest
@@ -10,8 +10,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}},
@@ -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': {