mirror of
https://github.com/google/earthengine-api.git
synced 2025-12-08 19:26:12 +00:00
317 lines
9.6 KiB
Python
317 lines
9.6 KiB
Python
#!/usr/bin/env python3
|
|
"""Test for the ee.serializer module."""
|
|
|
|
from collections.abc import Callable
|
|
import datetime
|
|
import json
|
|
from typing import Any
|
|
|
|
import unittest
|
|
import ee
|
|
from ee import apitestcase
|
|
from ee import serializer
|
|
|
|
|
|
def _max_depth(x: dict[str, Any] | list[Any] | str) -> int:
|
|
"""Computes the maximum nesting level of some dict, list, or str."""
|
|
if isinstance(x, dict):
|
|
return 1 + max(_max_depth(v) for v in x.values())
|
|
elif isinstance(x, list):
|
|
return 1 + max(_max_depth(v) for v in x)
|
|
else:
|
|
return 1
|
|
|
|
|
|
class DatetimeToMicrosecondsTest(unittest.TestCase):
|
|
|
|
def test_datetime_to_microseconds_naive(self):
|
|
self.assertEqual(
|
|
0,
|
|
serializer.DatetimeToMicroseconds(
|
|
datetime.datetime(1970, 1, 1, 0, 0, 0)
|
|
),
|
|
)
|
|
self.assertEqual(
|
|
1,
|
|
serializer.DatetimeToMicroseconds(
|
|
datetime.datetime(1970, 1, 1, 0, 0, 0, 1)
|
|
),
|
|
)
|
|
self.assertEqual(
|
|
1000000,
|
|
serializer.DatetimeToMicroseconds(
|
|
datetime.datetime(1970, 1, 1, 0, 0, 1)
|
|
),
|
|
)
|
|
self.assertEqual(
|
|
1407628800000000,
|
|
serializer.DatetimeToMicroseconds(datetime.datetime(2014, 8, 10)),
|
|
)
|
|
self.assertEqual(
|
|
-2010441600000000,
|
|
serializer.DatetimeToMicroseconds(datetime.datetime(1906, 4, 18)),
|
|
)
|
|
|
|
def test_datetime_to_microseconds(self):
|
|
self.assertEqual(
|
|
0,
|
|
serializer.DatetimeToMicroseconds(
|
|
datetime.datetime(1970, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
|
|
),
|
|
)
|
|
self.assertEqual(
|
|
1,
|
|
serializer.DatetimeToMicroseconds(
|
|
datetime.datetime(
|
|
1970, 1, 1, 0, 0, 0, 1, tzinfo=datetime.timezone.utc
|
|
)
|
|
),
|
|
)
|
|
self.assertEqual(
|
|
1000000,
|
|
serializer.DatetimeToMicroseconds(
|
|
datetime.datetime(1970, 1, 1, 0, 0, 1, tzinfo=datetime.timezone.utc)
|
|
),
|
|
)
|
|
self.assertEqual(
|
|
1407628800000000,
|
|
serializer.DatetimeToMicroseconds(
|
|
datetime.datetime(2014, 8, 10, tzinfo=datetime.timezone.utc)
|
|
),
|
|
)
|
|
self.assertEqual(
|
|
-2010441600000000,
|
|
serializer.DatetimeToMicroseconds(
|
|
datetime.datetime(1906, 4, 18, tzinfo=datetime.timezone.utc)
|
|
),
|
|
)
|
|
|
|
|
|
class SerializerTest(apitestcase.ApiTestCase):
|
|
|
|
def test_serialization(self):
|
|
"""Verifies a complex serialization case."""
|
|
|
|
class ByteString(ee.Encodable):
|
|
"""A custom Encodable class that does not use invocations.
|
|
|
|
This one is actually supported by the EE API encoding.
|
|
"""
|
|
_value: str
|
|
|
|
def __init__(self, value: str):
|
|
"""Creates a bytestring with a given string value."""
|
|
self._value = value
|
|
|
|
# pylint: disable-next=g-bad-name
|
|
def encode(self, encoder: Callable[[Any], Any]) -> dict[str, Any]:
|
|
del encoder # Unused.
|
|
return {'type': 'Bytes', 'value': self._value}
|
|
|
|
def encode_cloud_value(
|
|
self, encoder: Callable[[Any], Any]
|
|
) -> dict[str, str]:
|
|
del encoder # Unused.
|
|
# Proto3 JSON embedding of "bytes" values uses base64 encoding, which
|
|
# this already is.
|
|
return {'bytesValue': self._value}
|
|
|
|
call = ee.ComputedObject('String.cat', {'string1': 'x', 'string2': 'y'})
|
|
body = lambda x, y: ee.CustomFunction.variable(None, 'y')
|
|
sig = {'returns': 'Object',
|
|
'args': [
|
|
{'name': 'x', 'type': 'Object'},
|
|
{'name': 'y', 'type': 'Object'}]}
|
|
custom_function = ee.CustomFunction(sig, body)
|
|
to_encode = [
|
|
None,
|
|
True,
|
|
5,
|
|
7,
|
|
3.4,
|
|
112233445566778899,
|
|
'hello',
|
|
ee.Date(1234567890000),
|
|
ee.Geometry(ee.Geometry.LineString(1, 2, 3, 4), 'SR-ORG:6974'),
|
|
ee.Geometry.Polygon([
|
|
[[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]],
|
|
[[5, 6], [7, 6], [7, 8], [5, 8]],
|
|
[[1, 1], [2, 1], [2, 2], [1, 2]]
|
|
]),
|
|
ByteString('aGVsbG8='),
|
|
{
|
|
'foo': 'bar',
|
|
'baz': call
|
|
},
|
|
call,
|
|
custom_function
|
|
]
|
|
|
|
self.assertEqual(
|
|
apitestcase.ENCODED_JSON_SAMPLE,
|
|
json.loads(serializer.toJSON(to_encode, for_cloud_api=False)))
|
|
encoded = serializer.encode(to_encode, for_cloud_api=True)
|
|
self.assertEqual(apitestcase.ENCODED_CLOUD_API_JSON_SAMPLE, encoded)
|
|
pretty_encoded = serializer.encode(
|
|
to_encode, is_compound=False, for_cloud_api=True)
|
|
self.assertEqual(apitestcase.ENCODED_CLOUD_API_JSON_SAMPLE_PRETTY,
|
|
pretty_encoded)
|
|
|
|
encoded_json = serializer.toJSON(to_encode, for_cloud_api=True)
|
|
decoded_encoded_json = json.loads(encoded_json)
|
|
self.assertEqual(encoded, decoded_encoded_json)
|
|
|
|
def test_repeats(self):
|
|
"""Verifies serialization finds and removes repeated values."""
|
|
# pylint: disable-next=no-member
|
|
test1 = ee.Image(5).mask(ee.Image(5))
|
|
expected1 = {
|
|
'type': 'CompoundValue',
|
|
'scope': [
|
|
['0', {
|
|
'type': 'Invocation',
|
|
'arguments': {
|
|
'value': 5
|
|
},
|
|
'functionName': 'Image.constant'
|
|
}],
|
|
['1', {
|
|
'type': 'Invocation',
|
|
'arguments': {
|
|
'image': {
|
|
'type': 'ValueRef',
|
|
'value': '0'
|
|
},
|
|
'mask': {
|
|
'type': 'ValueRef',
|
|
'value': '0'
|
|
}
|
|
},
|
|
'functionName': 'Image.mask'
|
|
}]
|
|
],
|
|
'value': {
|
|
'type': 'ValueRef',
|
|
'value': '1'
|
|
}
|
|
}
|
|
self.assertEqual(expected1,
|
|
json.loads(serializer.toJSON(test1, for_cloud_api=False)))
|
|
expected_cloud = {
|
|
'values': {
|
|
'0': {
|
|
'functionInvocationValue': {
|
|
'arguments': {
|
|
'image': {
|
|
'valueReference': '1'
|
|
},
|
|
'mask': {
|
|
'valueReference': '1'
|
|
}
|
|
},
|
|
'functionName': 'Image.mask'
|
|
}
|
|
},
|
|
'1': {
|
|
'functionInvocationValue': {
|
|
'arguments': {
|
|
'value': {
|
|
'constantValue': 5
|
|
}
|
|
},
|
|
'functionName': 'Image.constant'
|
|
}
|
|
}
|
|
},
|
|
'result': '0'
|
|
}
|
|
expected_cloud_pretty = {
|
|
'functionInvocationValue': {
|
|
'arguments': {
|
|
'image': {
|
|
'functionInvocationValue': {
|
|
'arguments': {
|
|
'value': {
|
|
'constantValue': 5
|
|
}
|
|
},
|
|
'functionName': 'Image.constant'
|
|
}
|
|
},
|
|
'mask': {
|
|
'functionInvocationValue': {
|
|
'arguments': {
|
|
'value': {
|
|
'constantValue': 5
|
|
}
|
|
},
|
|
'functionName': 'Image.constant'
|
|
}
|
|
}
|
|
},
|
|
'functionName': 'Image.mask'
|
|
}
|
|
}
|
|
self.assertEqual(expected_cloud, serializer.encode(
|
|
test1, for_cloud_api=True))
|
|
self.assertEqual(
|
|
expected_cloud_pretty,
|
|
serializer.encode(test1, is_compound=False, for_cloud_api=True))
|
|
|
|
def test_depth_limit_with_algorithms(self):
|
|
x = ee.Number(0)
|
|
for i in range(100):
|
|
x = x.add(ee.Number(i))
|
|
encoded = serializer.encode(x, for_cloud_api=True)
|
|
# The default depth limit is 50, but there's some slop, so be a little loose
|
|
# on the test.
|
|
self.assertLess(_max_depth(encoded), 60)
|
|
|
|
def test_depth_limit_with_lists(self):
|
|
x = ee.List([0])
|
|
for i in range(100):
|
|
x = ee.List([i, x])
|
|
encoded = serializer.encode(x, for_cloud_api=True)
|
|
self.assertLess(_max_depth(encoded), 60)
|
|
|
|
def test_depth_limit_with_dictionaries(self):
|
|
x = ee.Dictionary({0: 0})
|
|
for i in range(100):
|
|
x = ee.Dictionary({i: x})
|
|
encoded = serializer.encode(x, for_cloud_api=True)
|
|
self.assertLess(_max_depth(encoded), 60)
|
|
|
|
def test_to_json_opt_params(self):
|
|
self.assertIn('\n', serializer.toJSON(ee.Image(0), opt_pretty=True))
|
|
self.assertNotIn('\n', serializer.toJSON(ee.Image(0), opt_pretty=False))
|
|
|
|
def test_datetime_serialization_legacy(self):
|
|
a_date = datetime.datetime(2014, 8, 10, tzinfo=datetime.timezone.utc)
|
|
# 1407628800000000 microseconds.
|
|
expected = {
|
|
'type': 'CompoundValue',
|
|
'scope': [],
|
|
'value': {
|
|
'type': 'Invocation',
|
|
'functionName': 'Date',
|
|
'arguments': {'value': 1407628800000.0},
|
|
},
|
|
}
|
|
self.assertEqual(expected, serializer.encode(a_date, for_cloud_api=False))
|
|
|
|
def test_single_value_no_compound(self):
|
|
"""Verifies serialization of a single non-primitive value."""
|
|
self.assertEqual([1], serializer.encode([1], for_cloud_api=False))
|
|
|
|
def test_unencodable_object(self):
|
|
class Unencodable:
|
|
pass
|
|
with self.assertRaisesRegex(ee.EEException, 'Cannot encode object: .*'):
|
|
serializer.encode(Unencodable(), for_cloud_api=False)
|
|
with self.assertRaisesRegex(ee.EEException, 'Cannot encode object: .*'):
|
|
serializer.encode(Unencodable(), for_cloud_api=True)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|