earthengine-api 1.7.6rc0__tar.gz → 1.7.8rc0__tar.gz

{earthengine_api-1.7.6rc0/earthengine_api.egg-info → earthengine_api-1.7.8rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: earthengine-api
-Version: 1.7.6rc0
+Version: 1.7.8rc0
 Summary: Earth Engine Python API
 Author-email: Google LLC <noreply@google.com>
 License: Apache-2.0

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0/earthengine_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: earthengine-api
-Version: 1.7.6rc0
+Version: 1.7.8rc0
 Summary: Earth Engine Python API
 Author-email: Google LLC <noreply@google.com>
 License: Apache-2.0

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/earthengine_api.egg-info/SOURCES.txt

@@ -91,6 +91,7 @@ ee/tests/ee_string_test.py
 ee/tests/ee_test.py
 ee/tests/ee_types_test.py
 ee/tests/element_test.py
+ee/tests/encodable_test.py
 ee/tests/errormargin_test.py
 ee/tests/feature_test.py
 ee/tests/featurecollection_test.py

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/__init__.py

@@ -1,6 +1,6 @@
 """The EE Python library."""
 
-__version__ = '1.7.6rc0'
+__version__ = '1.7.8rc0'
 
 # Using lowercase function naming to match the JavaScript names.
 # pylint: disable=g-bad-name

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/data.py

@@ -689,8 +689,10 @@ def getMapId(params: dict[str, Any]) -> dict[str, Any]:
   )
   state = _get_state()
   map_name = result['name']
-  url_format = '{}/{}/{}/tiles/{{z}}/{{x}}/{{y}}'.format(
-      state.tile_base_url, _cloud_api_utils.VERSION, map_name)
+  version = _cloud_api_utils.VERSION
+  url_format = (
+      '{state.tile_base_url}/{version}/{map_name)}/tiles/{{z}}/{{x}}/{{y}}'
+  )
   if state.cloud_api_key:
     url_format += f'?key={state.cloud_api_key}'
 
@@ -1199,9 +1201,9 @@ def makeThumbUrl(thumbId: dict[str, str]) -> str:
     A URL from which the thumbnail can be obtained.
   """
   state = _get_state()
-  url = '{}/{}/{}:getPixels'.format(
-      state.tile_base_url, _cloud_api_utils.VERSION, thumbId['thumbid']
-  )
+  version = _cloud_api_utils.VERSION
+  thumb_id = thumbId['thumbid']
+  url =  f'{state.tile_base_url}/{version}/{thumb_id}:getPixels'
   if state.cloud_api_key:
     url += f'?key={state.cloud_api_key}'
   return url
@@ -1332,9 +1334,10 @@ def makeDownloadUrl(downloadId: dict[str, str]) -> str:
   Returns:
     A URL from which the download can be obtained.
   """
-  return '{}/{}/{}:getPixels'.format(
-      _get_state().tile_base_url, _cloud_api_utils.VERSION, downloadId['docid']
-  )
+  title_base_url = _get_state().tile_base_url
+  version = _cloud_api_utils.VERSION
+  docid = downloadId['docid']
+  return f'{title_base_url}/{version}/{docid}:getPixels'
 
 
 def getTableDownloadId(params: dict[str, Any]) -> dict[str, str]:
@@ -1395,10 +1398,10 @@ def makeTableDownloadUrl(downloadId: dict[str, str]) -> str:
   Returns:
     A Url from which the download can be obtained.
   """
-  return '{}/{}/{}:getFeatures'.format(
-      _get_state().tile_base_url, _cloud_api_utils.VERSION, downloadId['docid']
-  )
-
+  title_base_url = _get_state().tile_base_url
+  version = _cloud_api_utils.VERSION
+  docid = downloadId['docid']
+  return f'{title_base_url}/{version}/{docid}:getFeatures'
 
 def getAlgorithms() -> Any:
   """Get the list of algorithms.

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/ee_list.py

@@ -422,8 +422,10 @@ class List(computedobject.ComputedObject):
   # TODO: Improve the type of `baseAlgorithm`.
   def map(
       self,
-      baseAlgorithm: _arg_types.Any,  # pylint: disable=invalid-name
+      # pylint: disable=invalid-name
+      baseAlgorithm: _arg_types.Any,
       dropNulls: _arg_types.Bool = False,
+      # pylint: enable=invalid-name
   ) -> List:
     """Map an algorithm over a list.
 

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/ee_types.py

@@ -77,6 +77,7 @@ def isSubtype(firstType: str, secondType: str) -> bool:
                           'Collection', 'ImageCollection', 'FeatureCollection')
   elif firstType in ('FeatureCollection', 'Collection'):
     return secondType in ('Collection', 'ImageCollection', 'FeatureCollection')
+  # TODO: elif firstType == 'Object':
   elif firstType == object:
     return True
   else:

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/encodable.py

@@ -1,4 +1,7 @@
-"""Interfaces implemented by serializable objects."""
+"""Interfaces implemented by serializable objects.
+
+This file has no implementation, only interfaces.
+"""
 
 from collections.abc import Callable
 from typing import Any

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/feature.py

@@ -28,10 +28,10 @@ class Feature(element.Element):
   def __init__(
       self,
       geom: None | (
-              Feature |
-              geometry.Geometry |
-              dict[str, Any] |
-              computedobject.ComputedObject
+          Feature |
+          geometry.Geometry |
+          dict[str, Any] |
+          computedobject.ComputedObject
       ),
       properties: None | (
           dict[str, Any] | computedobject.ComputedObject
@@ -682,6 +682,7 @@ class Feature(element.Element):
     )
 
   def setGeometry(
+      # pylint: disable-next=redefined-outer-name
       self, geometry: _arg_types.Geometry | None = None
   ) -> Feature:
     """Returns the feature with the geometry replaced by the specified geometry.

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/featurecollection.py

@@ -35,12 +35,12 @@ class FeatureCollection(collection.Collection[feature.Feature]):
   def __init__(
       self,
       args: None | (
-              dict[str, Any] |
-              list[Any] |
-              str |
-              feature.Feature |
-              geometry.Geometry |
-              computedobject.ComputedObject
+          dict[str, Any] |
+          list[Any] |
+          str |
+          feature.Feature |
+          geometry.Geometry |
+          computedobject.ComputedObject
       ),
       column: Any | None = None,
   ):

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/tests/algorithms.json

@@ -5894,7 +5894,7 @@
       "type": "Long",
       "description": "The version of the asset. -1 signifies the latest version. Ignored unless tableId is an asset ID.",
       "optional": true,
-      "defaultValue": null
+      "defaultValue": -1.0
     }]
   }, {
     "name": "algorithms/Collection.merge",
@@ -9404,7 +9404,7 @@
     }, {
       "argumentName": "size",
       "type": "Integer",
-      "description": "The size of the neighborhood to include in each GLCM.",
+      "description": "The size of the neighborhood to include in each GLCM. For example, the size of 1 corresponds to a 3x3 square, the size of 2 corresponds to a 5x5 square, the size of 3 corresponds to a 7x7 square, etc.",
       "optional": true,
       "defaultValue": 1.0
     }, {

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/tests/data_test.py

@@ -848,6 +848,131 @@ class DataTest(unittest.TestCase):
             cloud_api_resource.projects().maps().create.call_args_list[1]
             .kwargs['workloadTag'])
 
+  def test_get_map_id_with_string_image(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      with self.assertRaisesRegex(
+          ee.ee_exception.EEException, '^Image as JSON string not supported.'
+      ):
+        ee.data.getMapId({'image': 'my-image'})
+
+  def test_get_map_id_with_version(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      with self.assertRaisesRegex(
+          ee.ee_exception.EEException,
+          '^Image version specification not supported.',
+      ):
+        ee.data.getMapId({
+            'image': image.Image('my-image'),
+            'version': '123',
+        })
+
+  def test_get_map_id_with_vis_params(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      mock_result = {
+          'name': 'projects/earthengine-legacy/maps/DOCID',
+      }
+      cloud_api_resource.projects().maps().create().execute.return_value = (
+          mock_result
+      )
+      vis_params = {'paletteColors': ['FF0000']}
+      ee.data.getMapId({
+          'image': image.Image('my-image'),
+          'palette': 'FF0000',
+      })
+      self.assertEqual(
+          2, cloud_api_resource.projects().maps().create.call_count
+      )
+      kwargs = (
+          cloud_api_resource.projects().maps().create.call_args_list[1].kwargs
+      )
+      self.assertIn('body', kwargs)
+      self.assertIn('visualizationOptions', kwargs['body'])
+      self.assertEqual(vis_params, kwargs['body']['visualizationOptions'])
+
+  def test_get_map_id_with_cloud_api_key(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      ee.data._get_state().cloud_api_key = 'my-api-key'
+      mock_result = {
+          'name': 'projects/earthengine-legacy/maps/DOCID',
+      }
+      cloud_api_resource.projects().maps().create().execute.return_value = (
+          mock_result
+      )
+      actual_result = ee.data.getMapId({
+          'image': image.Image('my-image'),
+      })
+      self.assertIn('?key=my-api-key', actual_result['tile_fetcher'].url_format)
+
+  def test_get_thumbnail_default(self):
+    cloud_api_resource_raw = mock.MagicMock()
+    with apitestcase.UsingCloudApi(
+        cloud_api_resource_raw=cloud_api_resource_raw
+    ):
+      thumb_id = 'projects/earthengine-legacy/thumbnails/some-id'
+      thumb_id_result = {'thumbid': thumb_id}
+      img = image.Image('my-image')
+      img.getThumbId = mock.Mock(return_value=thumb_id_result)
+      params = {'image': img}
+      (
+          cloud_api_resource_raw.projects()
+          .thumbnails()
+          .getPixels.return_value.execute.return_value
+      ) = b'pixel data'
+      result = ee.data.getThumbnail(params)
+      self.assertEqual(b'pixel data', result)
+      img.getThumbId.assert_called_once_with(params)
+      cloud_api_resource_raw.projects().thumbnails().getPixels.assert_called_once_with(
+          name=thumb_id
+      )
+
+  def test_get_thumbnail_video(self):
+    cloud_api_resource_raw = mock.MagicMock()
+    with apitestcase.UsingCloudApi(
+        cloud_api_resource_raw=cloud_api_resource_raw
+    ):
+      thumb_id = 'projects/earthengine-legacy/videoThumbnails/some-id'
+      thumb_id_result = {'thumbid': thumb_id}
+      img = image.Image('my-image')
+      img.getThumbId = mock.Mock(return_value=thumb_id_result)
+      params = {'image': img}
+      (
+          cloud_api_resource_raw.projects()
+          .videoThumbnails()
+          .getPixels.return_value.execute.return_value
+      ) = b'video data'
+      result = ee.data.getThumbnail(params, thumbType='video')
+      self.assertEqual(b'video data', result)
+      img.getThumbId.assert_called_once_with(params)
+      cloud_api_resource_raw.projects().videoThumbnails().getPixels.assert_called_once_with(
+          name=thumb_id
+      )
+
+  def test_get_thumbnail_filmstrip(self):
+    cloud_api_resource_raw = mock.MagicMock()
+    with apitestcase.UsingCloudApi(
+        cloud_api_resource_raw=cloud_api_resource_raw
+    ):
+      thumb_id = 'projects/earthengine-legacy/filmstripThumbnails/some-id'
+      thumb_id_result = {'thumbid': thumb_id}
+      img = image.Image('my-image')
+      img.getThumbId = mock.Mock(return_value=thumb_id_result)
+      params = {'image': img}
+      (
+          cloud_api_resource_raw.projects()
+          .filmstripThumbnails()
+          .getPixels.return_value.execute.return_value
+      ) = b'filmstrip data'
+      result = ee.data.getThumbnail(params, thumbType='filmstrip')
+      self.assertEqual(b'filmstrip data', result)
+      img.getThumbId.assert_called_once_with(params)
+      cloud_api_resource_raw.projects().filmstripThumbnails().getPixels.assert_called_once_with(
+          name=thumb_id
+      )
+
   def test_get_download_id(self):
     cloud_api_resource = mock.MagicMock()
     with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
@@ -949,6 +1074,14 @@ class DataTest(unittest.TestCase):
             cloud_api_resource.projects().thumbnails().create.call_args
             .kwargs['workloadTag'])
 
+  def test_make_thumb_url_with_api_key(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      ee.data._get_state().cloud_api_key = 'my-api-key'
+      thumb_id = {'thumbid': 'projects/earthengine-legacy/thumbnails/some-id'}
+      url = ee.data.makeThumbUrl(thumb_id)
+      self.assertIn('?key=my-api-key', url)
+
   def test_get_table_download_id(self):
     cloud_api_resource = mock.MagicMock()
     with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/tests/daterange_test.py

@@ -272,6 +272,31 @@ class DateRangeTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
+  def test_unbounded(self):
+    expect = make_expression_graph({
+        'functionName': 'DateRange.unbounded',
+        'arguments': {},
+    })
+    expression = ee.DateRange.unbounded()
+    result = json.loads(expression.serialize())
+    self.assertEqual(expect, result)
+
+    is_unbounded_expect = make_expression_graph({
+        'arguments': {
+            'dateRange': {
+                'functionInvocationValue': {
+                    'functionName': 'DateRange.unbounded',
+                    'arguments': {},
+                }
+            }
+        },
+        'functionName': 'DateRange.isUnbounded',
+    })
+
+    is_unbounded_expression = expression.isUnbounded()
+    is_unbounded_result = json.loads(is_unbounded_expression.serialize())
+    self.assertEqual(is_unbounded_expect, is_unbounded_result)
+
   def test_union(self):
     expect = make_expression_graph({
         'arguments': {

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/tests/ee_list_test.py

@@ -47,6 +47,12 @@ class ListTest(apitestcase.ApiTestCase):
     self.assertEqual(expect, json.loads(ee.List(tuple([42])).serialize()))
     self.assertEqual(expect, json.loads(ee.List([42]).serialize()))
 
+  def test_bad_list(self):
+    with self.assertRaisesRegex(
+        ee.EEException, 'Invalid argument specified for ee.List'
+    ):
+      ee.List('not a list')  # pytype: disable=wrong-arg-types
+
   def test_mapping(self):
     lst = ee.List(['foo', 'bar'])
     body = lambda s: ee.String(s).cat('bar')
@@ -359,7 +365,31 @@ class ListTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
-  # TODO: test_iterate
+  def test_iterate(self):
+    lst = ee.List([1, 2, 3])
+    body = lambda n, p: ee.Number(p).add(n)
+    iterated = lst.iterate(body, 0)
+
+    self.assertIsInstance(iterated, ee.ComputedObject)
+    self.assertEqual(ee.ApiFunction.lookup('List.iterate'), iterated.func)
+    self.assertEqual(lst, iterated.args['list'])
+    self.assertEqual(0, iterated.args['first'])
+
+    sig = {
+        'returns': 'Object',
+        'args': [
+            {'name': '_MAPPING_VAR_0_0', 'type': 'Object'},
+            {'name': '_MAPPING_VAR_0_1', 'type': 'Object'},
+        ],
+    }
+    expected_function = ee.CustomFunction(sig, body)
+    self.assertEqual(
+        expected_function.serialize(), iterated.args['function'].serialize()
+    )
+    self.assertEqual(
+        expected_function.serialize(for_cloud_api=True),
+        iterated.args['function'].serialize(for_cloud_api=True),
+    )
 
   def test_join(self):
     expect = make_expression_graph({

earthengine_api-1.7.8rc0/ee/tests/ee_types_test.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Tests for ee_types.py."""
+
+import datetime
+
+import unittest
+from ee import apitestcase
+from ee import ee_list
+from ee import ee_number
+from ee import ee_types
+
+
+class EeTypesTest(apitestcase.ApiTestCase):
+
+  def test_class_to_name(self):
+    self.assertEqual('List', ee_types.classToName(ee_list.List))
+    self.assertEqual('Number', ee_types.classToName(ee_number.Number))
+    self.assertEqual('Number', ee_types.classToName(int))
+    self.assertEqual('Number', ee_types.classToName(float))
+    self.assertEqual('String', ee_types.classToName(str))
+    self.assertEqual('Array', ee_types.classToName(tuple))
+    self.assertEqual('Array', ee_types.classToName(list))
+    self.assertEqual('Array', ee_types.classToName(list))
+    self.assertEqual('Date', ee_types.classToName(datetime.datetime))
+
+    class Foo:
+      pass
+
+    self.assertEqual('Object', ee_types.classToName(Foo))
+
+  def test_is_subtype(self):
+    self.assertTrue(ee_types.isSubtype('Image', 'Image'))
+    self.assertTrue(ee_types.isSubtype('Element', 'Image'))
+    self.assertFalse(ee_types.isSubtype('Image', 'Element'))
+
+    self.assertTrue(ee_types.isSubtype('Collection', 'ImageCollection'))
+    self.assertTrue(ee_types.isSubtype('Collection', 'FeatureCollection'))
+
+    self.assertFalse(ee_types.isSubtype('ImageCollection', 'Collection'))
+
+    self.assertFalse(ee_types.isSubtype('Image', 'Collection'))
+    self.assertFalse(ee_types.isSubtype('ImageCollection', 'FeatureCollection'))
+
+    # TODO: Theses should be false.
+    self.assertTrue(ee_types.isSubtype('FeatureCollection', 'Collection'))
+    self.assertTrue(ee_types.isSubtype('FeatureCollection', 'ImageCollection'))
+
+  def test_is_array(self):
+    self.assertTrue(ee_types.isArray([]))
+    self.assertTrue(ee_types.isArray(()))
+    self.assertTrue(ee_types.isArray(ee_list.List([1, 2])))
+    self.assertFalse(ee_types.isArray(1))
+    self.assertFalse(ee_types.isArray('string'))
+    self.assertFalse(ee_types.isArray(ee_number.Number(1)))
+
+
+if __name__ == '__main__':
+  unittest.main()

earthengine_api-1.7.8rc0/ee/tests/element_test.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""Test for the ee.element module."""
+
+import datetime
+
+import unittest
+import ee
+from ee import apitestcase
+
+
+class ElementTestCase(apitestcase.ApiTestCase):
+
+  def test_set(self):
+    """Verifies Element.set() keyword argument interpretation."""
+    image = ee.Image(1)
+
+    # Constant dictionary.
+    def AssertProperties(expected, image):
+      properties = {}
+      while image.func == ee.ApiFunction.lookup('Element.set'):
+        key = image.args['key']
+        if not isinstance(key, str):
+          key = key.encode()
+        properties[key] = image.args['value']
+        image = image.args['object']
+      self.assertEqual(ee.Image(1), image)
+      self.assertEqual(expected, properties)
+
+    AssertProperties({'foo': 'bar'}, image.set({'foo': 'bar'}))
+    AssertProperties({'foo': 'bar'}, image.set({'properties': {'foo': 'bar'}}))
+    AssertProperties({'properties': 5}, image.set({'properties': 5}))
+    AssertProperties({'properties': {'foo': 'bar'}, 'baz': 'quux'},
+                     image.set({'properties': {'foo': 'bar'}, 'baz': 'quux'}))
+    AssertProperties({'foo': 'bar', 'baz': 'quux'},
+                     image.set('foo', 'bar', 'baz', 'quux'))
+    dt = datetime.datetime.fromtimestamp(12345)
+    AssertProperties({'foo': dt}, image.set('foo', dt))
+
+    # Computed dictionary.
+    computed_arg = ee.ComputedObject(None, None, 'foo')
+
+    def CheckMultiProperties(result):
+      self.assertEqual(ee.ApiFunction.lookup('Element.setMulti'), result.func)
+      self.assertEqual({
+          'object': image,
+          'properties': ee.Dictionary(computed_arg)
+      }, result.args)
+    CheckMultiProperties(image.set(computed_arg))
+    CheckMultiProperties(image.set({'properties': computed_arg}))
+
+  def test_set_one_arg_exception(self):
+    with self.assertRaisesRegex(
+        ee.EEException,
+        r'When Element\.set\(\) is passed one argument, '
+        r'it must be a dictionary\.',
+    ):
+      ee.Image(1).set('not a dictionary')
+
+  def test_set_odd_args_exception(self):
+    with self.assertRaisesRegex(
+        ee.EEException,
+        r'When Element\.set\(\) is passed multiple arguments, there '
+        r'must be an even number of them\.',
+    ):
+      ee.Image(1).set('key1', 'value1', 'key2')
+
+  def test_get_array(self):
+    image = ee.Image(1)
+    array_property = image.getArray('array_prop')
+    self.assertIsInstance(array_property, ee.Array)
+    self.assertEqual(
+        ee.ApiFunction.lookup('Element.getArray'), array_property.func
+    )
+    self.assertEqual(
+        {'object': image, 'property': ee.String('array_prop')},
+        array_property.args,
+    )
+
+  def test_get_number(self):
+    image = ee.Image(1)
+    number_property = image.getNumber('number_prop')
+    self.assertIsInstance(number_property, ee.Number)
+    self.assertEqual(
+        ee.ApiFunction.lookup('Element.getNumber'), number_property.func
+    )
+    self.assertEqual(
+        {'object': image, 'property': ee.String('number_prop')},
+        number_property.args,
+    )
+
+  def test_get_string(self):
+    image = ee.Image(1)
+    string_property = image.getString('string_prop')
+    self.assertIsInstance(string_property, ee.String)
+    self.assertEqual(
+        ee.ApiFunction.lookup('Element.getString'), string_property.func
+    )
+    self.assertEqual(
+        {'object': image, 'property': ee.String('string_prop')},
+        string_property.args,
+    )
+
+  def test_property_names(self):
+    image = ee.Image(1)
+    property_names = image.propertyNames()
+    self.assertIsInstance(property_names, ee.List)
+    self.assertEqual(
+        ee.ApiFunction.lookup('Element.propertyNames'), property_names.func
+    )
+    self.assertEqual({'element': image}, property_names.args)
+
+  def test_to_dictionary(self):
+    image = ee.Image(1)
+    dictionary = image.toDictionary()
+    self.assertIsInstance(dictionary, ee.Dictionary)
+    self.assertEqual(
+        ee.ApiFunction.lookup('Element.toDictionary'), dictionary.func
+    )
+    self.assertEqual({'element': image, 'properties': None}, dictionary.args)
+
+    dictionary_with_props = image.toDictionary(['a', 'b'])
+    self.assertIsInstance(dictionary_with_props, ee.Dictionary)
+    self.assertEqual(
+        ee.ApiFunction.lookup('Element.toDictionary'),
+        dictionary_with_props.func,
+    )
+    self.assertEqual(
+        {'element': image, 'properties': ee.List(['a', 'b'])},
+        dictionary_with_props.args,
+    )
+
+  def test_init_opt_params(self):
+    result = ee.Element(func=None, args=None, opt_varName='test').serialize()
+    self.assertIn('"0": {"argumentReference": "test"}', result)
+
+
+if __name__ == '__main__':
+  unittest.main()

earthengine_api-1.7.8rc0/ee/tests/encodable_test.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""Tests for ee.encodable."""
+
+from collections.abc import Callable
+from typing import Any
+import unittest
+
+from ee import encodable
+
+
+class EncodableTest(unittest.TestCase):
+
+  def test_encodable(self):
+    encoder: Callable[[Any], Any] = lambda x: x
+    with self.assertRaises(NotImplementedError):
+      encodable.Encodable().encode(encoder)
+    with self.assertRaises(NotImplementedError):
+      encodable.Encodable().encode_cloud_value(encoder)
+
+  def test_encodable_function(self):
+    encoder: Callable[[Any], Any] = lambda x: x
+    with self.assertRaises(NotImplementedError):
+      encodable.EncodableFunction().encode_invocation(encoder)
+    with self.assertRaises(NotImplementedError):
+      encodable.EncodableFunction().encode_cloud_invocation(encoder)
+
+
+if __name__ == '__main__':
+  unittest.main()

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/tests/feature_test.py

@@ -121,6 +121,30 @@ class FeatureTest(apitestcase.ApiTestCase):
         'system:index': 'bar'
     }, from_geo_json_feature.args['metadata'])
 
+  def test_feature_copy(self):
+    feature = ee.Feature(ee.Geometry.Point(1, 2), {'x': 1})
+    feature_copy = ee.Feature(feature)
+    self.assertEqual(feature.func, feature_copy.func)
+    self.assertEqual(feature.args, feature_copy.args)
+
+  def test_feature_with_properties_exception(self):
+    with self.assertRaisesRegex(
+        ee.EEException, 'Cannot create Feature out of a Feature and properties'
+    ):
+      ee.Feature(ee.Feature(None), {'x': 2})
+
+  def test_id_and_system_index_exception(self):
+    point = ee.Geometry.Point(1, 2)
+    with self.assertRaisesRegex(
+        ee.EEException, 'Cannot specify both "id" and "system:index"'
+    ):
+      ee.Feature({
+          'type': 'Feature',
+          'id': 'bar',
+          'geometry': point.toGeoJSON(),
+          'properties': {'system:index': 'bar'},
+      })
+
   def test_get_map(self):
     """Verifies that getMap() uses Collection.draw to rasterize Features."""
     feature = ee.Feature(None)

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/ee/tests/featurecollection_test.py

@@ -96,6 +96,19 @@ class FeatureCollectionTest(apitestcase.ApiTestCase):
         ee.ComputedObject(None, {'x': 'y'}))
     self.assertEqual({'x': 'y'}, from_computed_object.args)
 
+  def test_invalid_constructor_args(self):
+    with self.assertRaisesRegex(
+        ee.EEException,
+        'Unrecognized argument type to convert to a FeatureCollection: 1',
+    ):
+      ee.FeatureCollection(1)
+
+    with self.assertRaisesRegex(
+        ee.EEException,
+        'Unrecognized argument type to convert to a FeatureCollection: None',
+    ):
+      ee.FeatureCollection(None)
+
   def test_get_map_id(self):
     """Verifies that getMap() uses Collection.draw to draw."""
     collection = ee.FeatureCollection('test5')
@@ -126,6 +139,13 @@ class FeatureCollectionTest(apitestcase.ApiTestCase):
         ee.FeatureCollection('test7').getDownloadUrl('csv'),
         ee.FeatureCollection('test7').getDownloadURL('csv'))
 
+    ee.FeatureCollection('test9').getDownloadURL(selectors=['bar', 'baz'])
+    self.assertEqual(
+        ee.FeatureCollection('test9').serialize(),
+        self.last_table_call['data']['table'].serialize(),
+    )
+    self.assertEqual('bar,baz', self.last_table_call['data']['selectors'])
+
   def test_download_table_with_cloud_api(self):
     cloud_api_resource = mock.MagicMock()
     with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):

{earthengine_api-1.7.6rc0 → earthengine_api-1.7.8rc0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "earthengine-api"
-version = "1.7.6rc0"
+version = "1.7.8rc0"
 description = "Earth Engine Python API"
 readme = "README.md"
 requires-python = ">=3.10"

earthengine_api-1.7.6rc0/ee/tests/ee_types_test.py

@@ -1,32 +0,0 @@
-#!/usr/bin/env python3
-"""Tests for ee_types.py."""
-
-import datetime
-
-import unittest
-from ee import ee_list
-from ee import ee_number
-from ee import ee_types
-
-
-class EeTypesTest(unittest.TestCase):
-
-  def test_class_to_name(self):
-    self.assertEqual('List', ee_types.classToName(ee_list.List))
-    self.assertEqual('Number', ee_types.classToName(ee_number.Number))
-    self.assertEqual('Number', ee_types.classToName(int))
-    self.assertEqual('Number', ee_types.classToName(float))
-    self.assertEqual('String', ee_types.classToName(str))
-    self.assertEqual('Array', ee_types.classToName(tuple))
-    self.assertEqual('Array', ee_types.classToName(list))
-    self.assertEqual('Array', ee_types.classToName(list))
-    self.assertEqual('Date', ee_types.classToName(datetime.datetime))
-
-    class Foo:
-      pass
-
-    self.assertEqual('Object', ee_types.classToName(Foo))
-
-
-if __name__ == '__main__':
-  unittest.main()

earthengine_api-1.7.6rc0/ee/tests/element_test.py

@@ -1,57 +0,0 @@
-#!/usr/bin/env python3
-"""Test for the ee.element module."""
-
-import datetime
-
-import unittest
-import ee
-from ee import apitestcase
-
-
-class ElementTestCase(apitestcase.ApiTestCase):
-
-  def test_set(self):
-    """Verifies Element.set() keyword argument interpretation."""
-    image = ee.Image(1)
-
-    # Constant dictionary.
-    def AssertProperties(expected, image):
-      properties = {}
-      while image.func == ee.ApiFunction.lookup('Element.set'):
-        key = image.args['key']
-        if not isinstance(key, str):
-          key = key.encode()
-        properties[key] = image.args['value']
-        image = image.args['object']
-      self.assertEqual(ee.Image(1), image)
-      self.assertEqual(expected, properties)
-
-    AssertProperties({'foo': 'bar'}, image.set({'foo': 'bar'}))
-    AssertProperties({'foo': 'bar'}, image.set({'properties': {'foo': 'bar'}}))
-    AssertProperties({'properties': 5}, image.set({'properties': 5}))
-    AssertProperties({'properties': {'foo': 'bar'}, 'baz': 'quux'},
-                     image.set({'properties': {'foo': 'bar'}, 'baz': 'quux'}))
-    AssertProperties({'foo': 'bar', 'baz': 'quux'},
-                     image.set('foo', 'bar', 'baz', 'quux'))
-    dt = datetime.datetime.fromtimestamp(12345)
-    AssertProperties({'foo': dt}, image.set('foo', dt))
-
-    # Computed dictionary.
-    computed_arg = ee.ComputedObject(None, None, 'foo')
-
-    def CheckMultiProperties(result):
-      self.assertEqual(ee.ApiFunction.lookup('Element.setMulti'), result.func)
-      self.assertEqual({
-          'object': image,
-          'properties': ee.Dictionary(computed_arg)
-      }, result.args)
-    CheckMultiProperties(image.set(computed_arg))
-    CheckMultiProperties(image.set({'properties': computed_arg}))
-
-  def test_init_opt_params(self):
-    result = ee.Element(func=None, args=None, opt_varName='test').serialize()
-    self.assertIn('"0": {"argumentReference": "test"}', result)
-
-
-if __name__ == '__main__':
-  unittest.main()