earthengine-api 1.6.15__py3-none-any.whl → 1.7.0__py3-none-any.whl

ee/serializer.py

@@ -4,7 +4,7 @@ import collections
 import datetime
 import hashlib
 import json
-from typing import Any, Optional
+from typing import Any
 
 from ee import _cloud_api_utils
 from ee import _utils
@@ -32,7 +32,7 @@ def DatetimeToMicroseconds(date: datetime.datetime) -> int:
 
 class Serializer:
   """A serializer for EE object trees."""
-  unbound_name: Optional[str]
+  unbound_name: str | None
 
   # Whether the encoding should factor out shared subtrees.
   _is_compound: bool
@@ -48,7 +48,7 @@ class Serializer:
       self,
       is_compound: bool = True,
       for_cloud_api: bool = False,
-      unbound_name: Optional[str] = None,
+      unbound_name: str | None = None,
   ):
     """Constructs a serializer.
 
@@ -280,7 +280,7 @@ def encode(
     obj: Any,
     is_compound: bool = True,
     for_cloud_api: bool = True,
-    unbound_name: Optional[str] = None,
+    unbound_name: str | None = None,
 ) -> Any:
   """Serialize an object to a JSON-compatible structure for API calls.
 
@@ -358,7 +358,7 @@ class _ExpressionOptimizer:
   - Collapse dicts and arrays of constants to constant dicts/arrays.
   """
 
-  def __init__(self, result: Any, values: Optional[Any] = None):
+  def __init__(self, result: Any, values: Any | None = None):
     """Builds an ExpressionOptimizer.
 
     Args:
@@ -385,7 +385,7 @@ class _ExpressionOptimizer:
     reference_counts = collections.defaultdict(int)
     reference_counts[self._result] += 1
 
-    def _contained_reference(value: Any) -> Optional[Any]:
+    def _contained_reference(value: Any) -> Any | None:
       """Gets a contained reference from a ValueNode, if there is one."""
       if 'functionDefinitionValue' in value:
         return value['functionDefinitionValue']['body']

ee/table_converter.py

@@ -1,7 +1,7 @@
 """Converters used in the table data fetching methods."""
 
 from collections.abc import Iterator
-from typing import Any, Optional, Union
+from typing import Any
 
 
 class TableConverter:
@@ -59,8 +59,8 @@ _TABLE_DATA_CONVERTERS: dict[str, type[TableConverter]] = {
 
 
 def from_file_format(
-    file_format: Union[str, TableConverter]
-) -> Optional[TableConverter]:
+    file_format: str | TableConverter
+) -> TableConverter | None:
   if isinstance(file_format, TableConverter):
     return file_format
   if file_format in _TABLE_DATA_CONVERTERS:

ee/tests/batch_test.py

@@ -2,7 +2,7 @@
 """Test for the ee.batch module."""
 
 import json
-from typing import Any, Optional
+from typing import Any
 import unittest
 from unittest import mock
 
@@ -201,8 +201,8 @@ class ExportTest(unittest.TestCase):
 class BatchTestCase(apitestcase.ApiTestCase):
   """A test case for batch functionality."""
 
-  start_call_params: Optional[Any]
-  update_call_params: Optional[Any]
+  start_call_params: Any | None
+  update_call_params: Any | None
 
   def setUp(self):
     super().setUp()

ee/tests/collection_test.py

@@ -47,6 +47,10 @@ class CollectionTestCase(apitestcase.ApiTestCase):
 
     # We don't allow empty filters.
     self.assertRaises(Exception, collection.filter)
+    with self.assertRaisesRegex(ee.EEException, 'Empty filters.'):
+      collection.filter(None)  # pytype: disable=wrong-arg-types
+    with self.assertRaisesRegex(ee.EEException, 'Empty filters.'):
+      collection.filter('')
 
     filtered = collection.filter(ee.Filter.eq('foo', 1))
     self.assertEqual(ee.ApiFunction.lookup('Collection.filter'), filtered.func)
@@ -75,6 +79,37 @@ class CollectionTestCase(apitestcase.ApiTestCase):
         collection.filter(ee.Filter.eq('foo', 13)),
         collection.filterMetadata('foo', 'equals', 13))
 
+  def test_load_table(self):
+    """Verifies Collection.loadTable()."""
+    table_id = 'a/table/id'
+    geometry_column = 'geom'
+    version = 123
+    result = ee.Collection.loadTable(
+        tableId=table_id, geometryColumn=geometry_column, version=version
+    )
+    self.assertEqual(ee.ApiFunction.lookup('Collection.loadTable'), result.func)
+    self.assertEqual(
+        {
+            'tableId': ee.String(table_id),
+            'geometryColumn': ee.String(geometry_column),
+            'version': ee.Number(version),
+        },
+        result.args,
+    )
+    self.assertIsInstance(result, ee.FeatureCollection)
+
+    result2 = ee.Collection.loadTable(tableId=table_id)
+    self.assertEqual(ee.ApiFunction.lookup('Collection.loadTable'), result2.func)
+    self.assertEqual(
+        {
+            'tableId': ee.String(table_id),
+            'geometryColumn': None,
+            'version': None,
+        },
+        result2.args,
+    )
+    self.assertIsInstance(result2, ee.FeatureCollection)
+
   def test_mapping(self):
     """Verifies the behavior of the map() method."""
     collection = ee.ImageCollection('foo')

ee/tests/data_test.py

@@ -2,7 +2,7 @@
 """Test for the ee.data module."""
 
 import json
-from typing import Any, Optional
+from typing import Any
 from unittest import mock
 
 import googleapiclient
@@ -28,7 +28,7 @@ def NotFoundError() -> googleapiclient.errors.HttpError:
 
 
 def NewFolderAsset(
-    name: str, quota: Optional[dict[str, int]] = None
+    name: str, quota: dict[str, int] | None = None
 ) -> dict[str, Any]:
   return {
       'type': 'FOLDER',
@@ -66,7 +66,9 @@ class DataTest(unittest.TestCase):
     mock_install_cloud_api_resource.assert_called_once()
 
   @mock.patch.object(ee.data, '_install_cloud_api_resource', return_value=None)
-  def test_initialize_with_project(self, unused_mock_install_cloud_api_resource):
+  def test_initialize_with_project(
+      self, unused_mock_install_cloud_api_resource
+  ):
     ee.data.initialize(project='my-project')
 
     self.assertTrue(ee.data.is_initialized())

ee/tests/ee_number_test.py

@@ -396,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': {
@@ -795,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({

ee/tests/image_converter_test.py

@@ -1,8 +1,6 @@
 #!/usr/bin/env python3
 """Tests for the image_converter module."""
 
-from typing import Optional
-
 from absl.testing import parameterized
 import numpy
 
@@ -20,7 +18,7 @@ class ImageConverterTest(parameterized.TestCase):
   def test_from_file_format(
       self,
       data_format: str,
-      expected: Optional[type[image_converter.ImageConverter]],
+      expected: type[image_converter.ImageConverter] | None,
   ) -> None:
     """Verifies `from_file_format` returns the correct converter class."""
     if expected is None:

ee/tests/serializer_test.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
 """Test for the ee.serializer module."""
 
+from collections.abc import Callable
 import datetime
 import json
-from typing import Any, Callable, Union
+from typing import Any
 
 import unittest
 import ee
@@ -11,7 +12,7 @@ from ee import apitestcase
 from ee import serializer
 
 
-def _max_depth(x: Union[dict[str, Any], list[Any], str]) -> int:
+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())

ee/tests/table_converter_test.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Tests for the table_converter module."""
 
-from typing import Any, Optional
+from typing import Any
 
 from absl.testing import parameterized
 import geopandas
@@ -28,7 +28,7 @@ class TableConverterTest(parameterized.TestCase):
   def test_from_file_format(
       self,
       data_format: str,
-      expected: Optional[type[table_converter.TableConverter]],
+      expected: type[table_converter.TableConverter] | None,
   ) -> None:
     """Verifies `from_file_format` returns the correct converter class."""
     if expected is None: