earthengine-api 1.7.7rc0__py3-none-any.whl → 1.7.9__py3-none-any.whl

{earthengine_api-1.7.7rc0.dist-info → earthengine_api-1.7.9.dist-info}/METADATA

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

{earthengine_api-1.7.7rc0.dist-info → earthengine_api-1.7.9.dist-info}/RECORD

@@ -1,5 +1,5 @@
-earthengine_api-1.7.7rc0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ee/__init__.py,sha256=rDU5yyDT731tZQhWqtHaNCsiUhA4bNZeuEB37dHZotg,16762
+earthengine_api-1.7.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ee/__init__.py,sha256=egVqpmJfMrMKvX_gT-jVCpbVrq4erXjuDEDLD-5oRLM,16759
 ee/_arg_types.py,sha256=nrJrnPFnAS8fzMxAGmG3TbUOi_yFVrnSGW5IP8ATzDQ,2662
 ee/_cloud_api_utils.py,sha256=5WPzP5bcBIbjA7yYN-Cwmht_HU-XobbTrZvRiOEn0e0,32890
 ee/_helpers.py,sha256=afDDqoz1WESKE-lzqLtrCbvoQ1yVpfvJIgFcmUjO4L8,4821
@@ -15,7 +15,7 @@ ee/collection.py,sha256=c8OFIX9OVLxTbu8HGYiHOS3Yg6QjnxaO_FAhDhDQpic,32588
 ee/computedobject.py,sha256=Cdlccd4vw2neeRQlo5Jn3Q5R-VpQcQufNuxOHfpd1FU,9186
 ee/confusionmatrix.py,sha256=e6vz-FcT6acWxk5pDEK0vLIN1pUjYMh5Gyn1QSGJT3I,4233
 ee/customfunction.py,sha256=Me_iHDnjkYR33JMttGA7pKJlPCjUk8rO_kgaIhDm27M,7408
-ee/data.py,sha256=nuebPtBm3rBZMHGqxakSZmskDGFA52aip-9zOmXwBL0,85374
+ee/data.py,sha256=GdskXveIWk4hFMqd0T0P6qoOUEEP8MO1XE4LX2hc8lU,85503
 ee/daterange.py,sha256=nrRYkR2M2aVU0ZJyG7yiZStFt-W2TvYVuazoZK_WZqM,4948
 ee/deprecation.py,sha256=mAFdO7fBjOu9TJd8CJB_M_NsZ6VNSxtSe820QKJx8fE,6243
 ee/deserializer.py,sha256=TjhQjcBnFpz8Kodoj74eSbvkJ2zLjpTTfUpcNEoQR2o,8357
@@ -23,15 +23,15 @@ ee/dictionary.py,sha256=b0t46vaeVMsFGI2icdGNspmedRtVVxfiIcFLWcmL2v8,10508
 ee/ee_array.py,sha256=EJmQ-zku1x0e6z44SlVD-F7mafmvRS0DoByKFyeDCuc,36368
 ee/ee_date.py,sha256=ixmLMrrGjq30DX9QY92HTeUgFZhWdn485cyaJkksh6U,10757
 ee/ee_exception.py,sha256=uN3X76HuhicU0LTxqRKQu1ZU6L7zw0GuABgsBTT-Ycw,164
-ee/ee_list.py,sha256=-jf0-zcqiiNexX_6GLZaRKotfmLabJ2o071Bv3MF6kI,19819
+ee/ee_list.py,sha256=UszZsQoAyJR-ms7trDXaZKf2-Mo2EpNLCf7pfxvCTk8,19860
 ee/ee_number.py,sha256=nNcgntUyc4h-zYLKcBIlanucxsiKqXC_koN-pzmuBnc,22376
 ee/ee_string.py,sha256=eg-dR1JAuazNFyOJsbCULQn3BvBpQd5LER8oDfWtXcU,7875
-ee/ee_types.py,sha256=wQCE74pDRxz_IAYc6hjSSqJwp5ozOIoZF0cHijTd8Sg,3081
+ee/ee_types.py,sha256=HHMZqgwSQ_zOLgPZ2cN45qCyJvIY7wl4GA3OPEzAM7M,3119
 ee/element.py,sha256=SdIVljB0Sbut02a61XgsPLiJpA66n34fsYZGMwsS8jQ,6261
-ee/encodable.py,sha256=J9QanzbB-_f5LUCQcIhrEV5W9CbRZtxa5gicmSVxLsk,1911
+ee/encodable.py,sha256=bZLsuIPNO5_nOBuwnbhuxTRcjTKqFPgL8ox7uy41w6M,1963
 ee/errormargin.py,sha256=x8kAgFeUdXmpc_kv8Vx5qv-fHeJvFU9EBFbSOxhNl8Y,3039
-ee/feature.py,sha256=WItnwlQp8U3D0E0YkgJNXIAk2JviwloS9c8j2XqbKEM,30292
-ee/featurecollection.py,sha256=XbDgzYEEyhim0_y2AOD5Wi-TRIl90OnB1DHtAJXgvg8,14424
+ee/feature.py,sha256=Qp5Dyl0eM6yjmQSH0D-dc9LEeKMCqlNibYJ9jOhHsaE,30326
+ee/featurecollection.py,sha256=HBLIAS0HogRzTEVHaLn-X9ONfdu5qFvN_6Bb54KYQ28,14400
 ee/filter.py,sha256=GKz3IqeZSrK4X26TjWaw_uOE8KjZgSx1pS1zM07PXfI,35321
 ee/function.py,sha256=X-Mz0AvF_l809NZXK8RM6fa2h-nP7YU2sUFp6hvIbdU,7049
 ee/geometry.py,sha256=D__UeT72DDaJFakmyaPnmfHwxNtDxLJW7Vbze0Hh2Y4,59517
@@ -69,30 +69,31 @@ ee/tests/clusterer_test.py,sha256=B4m06wAtBeqvnIhRD2lnNy1UHDB_caleK_CqcrAU8dk,11
 ee/tests/collection_test.py,sha256=zsBerYrFr390awe-wD8uN9VME_qEsuaEN197hom4Xps,8815
 ee/tests/computedobject_test.py,sha256=B27rDq9Urpvy0WqpdbKRYbt6AcT1i93HX-es7hrhWVY,4840
 ee/tests/confusionmatrix_test.py,sha256=46JJh1-91AiYISXWZ6-2lvY5_Njvc8ompO9kmwqlFdg,7437
-ee/tests/data_test.py,sha256=8oiSnzGoOtWx3YIld8owWYw1zC517uLkq1Uf2Xn4iCI,52063
-ee/tests/daterange_test.py,sha256=a5fpg2lko3kCJzxQPCoAc_vjXkKy2zYcXbeSZKAFovI,8583
+ee/tests/data_test.py,sha256=SBxHQqgZ4kEaWR13MWa-XPBuUr06keImvbp0t308wuY,57306
+ee/tests/daterange_test.py,sha256=7gEhFCWEa2KJW_ZaQMBavuJ0wLtUcVgsD8COF7NOd98,9389
 ee/tests/deprecation_test.py,sha256=CoVug7J9YdB2utZ-BikyJcjitYPQLz49JL_z89xuQSQ,8484
 ee/tests/deserializer_test.py,sha256=i_tlyzKgCo1-VpWPAQnTWNcr2klourcMcBbFZJN6Ivw,5050
 ee/tests/dictionary_test.py,sha256=IRaXMr3GzZFQ5BiHdB35Iio2TckIK67Cnp6KH0h8Aa8,11818
 ee/tests/ee_array_test.py,sha256=JVXShdbOVOjlfSpNgYc_NVrknQatuPOZ19fG0Ii5yVU,50268
 ee/tests/ee_date_test.py,sha256=8rLUXfjyiW3LiBOCSneA7ZGgmoFgN5oZr58x5THtKGY,11106
-ee/tests/ee_list_test.py,sha256=yd2EWZGdg7pLJhsHSR5AbK58ZhT31GY-n2o1dDT3p9A,21797
+ee/tests/ee_list_test.py,sha256=-EtJE4YoDjPoyk8co8XHnbxHZexZbX90XCqQ-PO2r8M,22838
 ee/tests/ee_number_test.py,sha256=YuJAWg4V4ELCLdmpEN7f4Wc_6ayOreWKui8ZM5fkjbg,35029
 ee/tests/ee_string_test.py,sha256=X6XJwa09yJXhg0rIpRb4QFA3eeGIrh2XClwhVByMRBY,9664
 ee/tests/ee_test.py,sha256=CY5XUfh_5Bx6yIUrHDI1SbVfztIgejB-LGdgCMgT0IA,17835
-ee/tests/ee_types_test.py,sha256=oRnqplaTWg47zuYfAYTTVwembCnw8XT20HPNMdAvgNE,921
-ee/tests/element_test.py,sha256=Gft1vmSeuhSelRHsdGKHd3S1xucnUQJh8ZlGSZ2JxRw,1968
+ee/tests/ee_types_test.py,sha256=-ZDZxPiAbKHHCBa8_z3sU5CRpnX07EZUIQc0tD-QTE4,2048
+ee/tests/element_test.py,sha256=Fgxmg6wTC2VtoQXkn6rTSA3ifdhKNjtEdgxzdgXpQDs,4638
+ee/tests/encodable_test.py,sha256=tRCtW6HO5-OnjXlxVUEUgoVrEOllvs-Z9pWMXISMYHQ,836
 ee/tests/errormargin_test.py,sha256=YEBzvBFsD756nicZBcjnPFAXy06jZNKiSSAa2hAzN-M,5061
-ee/tests/feature_test.py,sha256=-iq-p9xidPV0WE398j1nWL6Gn4Yvi_CQRetHbHhDooM,22514
-ee/tests/featurecollection_test.py,sha256=b3SwieXb8nyRzAlwKK_nSa4xGcy5AynIDZ1A3sV02Es,38440
+ee/tests/feature_test.py,sha256=-9wJgY-eJM53ZKYjRcnfWAZXjkF_u8Tn4I1wc209R0U,23336
+ee/tests/featurecollection_test.py,sha256=CXy240UIRCJNY6nZ8wW-u2O9MqFkUX-ZVba9wTr8OTU,39118
 ee/tests/filter_test.py,sha256=d-KQ_zI-r7BAMazKqqHMMzNUZdeC46BZiciMfthKEO8,35033
-ee/tests/function_test.py,sha256=0hv7H-Q21vdDvqHNH_3NvFj_nPEWM2Fh7CD0wgjXE2M,3131
+ee/tests/function_test.py,sha256=60Yl3K6VvOsObW3jhbhWnb9TzBjdQne63wbZWuyQxbY,3524
 ee/tests/geometry_point_test.py,sha256=w9MYTwvw2Co9rIjffFB0ezQ_jZz8nxbdgOcyhqTTmjk,15093
 ee/tests/geometry_test.py,sha256=5cNblTtXg4gg0k1_6go4XL2EldY2StOfD7sQ7Bu0WZU,32424
 ee/tests/image_converter_test.py,sha256=x29StMrzv6jlATtx3XXC7rEo7Cgrcx0XyVoM-ccVuao,1853
-ee/tests/image_test.py,sha256=_SJmee7orPot26vbxKEZcNZ6OsrNrxv3ToInWYLNZLM,150917
-ee/tests/imagecollection_test.py,sha256=qosRZXCbhwFuy8qR7DbA-FMl4ktW7Y2cUJHeXLcszpg,38444
-ee/tests/join_test.py,sha256=pFILq3qM27rO64WYbBC1A_Gs8_pabRv68X7MU_EM_cw,7630
+ee/tests/image_test.py,sha256=bhu_GLQy0jRJORVNHnpShOHzg-ZptE3XG3r_APiJ4n4,152371
+ee/tests/imagecollection_test.py,sha256=M2WdkCPx-w7wWFGw9q2XHRAXo7rCMAqIZknjhldlPs4,41535
+ee/tests/join_test.py,sha256=uuMW2tvHVoBXuanhcsJ95cQTfRjJTs5gmaPrzAJZrGM,7860
 ee/tests/kernel_test.py,sha256=-0nZVNSxE1IGs4y60oijISh2Hi1V7NCjrmUnEMDd0nQ,19378
 ee/tests/model_test.py,sha256=dgnWfqR4R4MIUljMBL1TOcztzA-lWEl7cT5f2Y0k2ck,12483
 ee/tests/oauth_test.py,sha256=8hldNiR3AYtQkWA4vwwSAO6jDIsh_fww7b_cOI9MJjo,9202
@@ -102,8 +103,8 @@ ee/tests/reducer_test.py,sha256=vqXpgLZ7fPyfZ12srpREgMpfrKYLcFQod3Qn1Niv7VM,3197
 ee/tests/serializer_test.py,sha256=d6IEW_dt-G900IRfQnZftrwjpc1wJ-ouaQQwaLO0FxI,9834
 ee/tests/table_converter_test.py,sha256=t4yIfy40R3U17I_2nVtKm_Q2Tae-UifwZLz8qOmoC9A,5091
 ee/tests/terrain_test.py,sha256=inZ2sy807nDG_HMutzGHaqcTUaLnZQOMdWyf0NrQzV0,4561
-earthengine_api-1.7.7rc0.dist-info/METADATA,sha256=QVtJ6bHiuN8SkNyQx0ppDbshaV6WAmwN7NoV2Tf10KY,2198
-earthengine_api-1.7.7rc0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-earthengine_api-1.7.7rc0.dist-info/entry_points.txt,sha256=-Ax4SCU-S474r8OD2LIxata6PRmkZoDrppQ4fP_exNc,50
-earthengine_api-1.7.7rc0.dist-info/top_level.txt,sha256=go5zOwCgm5lIS3yTR-Vsxp1gNI4qdS-MP5eY-7zMxVY,3
-earthengine_api-1.7.7rc0.dist-info/RECORD,,
+earthengine_api-1.7.9.dist-info/METADATA,sha256=lebc7nR6BBje0swYH-S9jec7wr2Tc0skwu1bnyfWwWE,2195
+earthengine_api-1.7.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+earthengine_api-1.7.9.dist-info/entry_points.txt,sha256=-Ax4SCU-S474r8OD2LIxata6PRmkZoDrppQ4fP_exNc,50
+earthengine_api-1.7.9.dist-info/top_level.txt,sha256=go5zOwCgm5lIS3yTR-Vsxp1gNI4qdS-MP5eY-7zMxVY,3
+earthengine_api-1.7.9.dist-info/RECORD,,

ee/__init__.py

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

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.

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.
 

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:

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

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.

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,
   ):

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):

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': {

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({

ee/tests/ee_types_test.py

@@ -4,12 +4,13 @@
 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(unittest.TestCase):
+class EeTypesTest(apitestcase.ApiTestCase):
 
   def test_class_to_name(self):
     self.assertEqual('List', ee_types.classToName(ee_list.List))
@@ -27,6 +28,31 @@ class EeTypesTest(unittest.TestCase):
 
     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()

ee/tests/element_test.py

@@ -48,6 +48,87 @@ class ElementTestCase(apitestcase.ApiTestCase):
     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)

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()

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)

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):

ee/tests/function_test.py

@@ -34,6 +34,11 @@ Args:
 
 class FunctionTest(unittest.TestCase):
 
+  def test_get_signature_not_implemented(self):
+    message = 'Function subclasses must implement getSignature()'
+    with self.assertRaisesRegex(NotImplementedError, message):
+      ee.Function().getSignature()
+
   def test_name_args(self):
     """Verifies that Functions can convert positional to named arguments."""
     self.assertEqual({}, TEST_FUNC.nameArgs([]))
@@ -43,6 +48,13 @@ class FunctionTest(unittest.TestCase):
 
     self.assertRaisesRegex(ee.EEException, 'Too many', TEST_FUNC.nameArgs,
                            [1, 2, 3])
+    self.assertRaisesRegex(
+        ee.EEException,
+        'Argument a specified as both positional and keyword',
+        TEST_FUNC.nameArgs,
+        [1],
+        {'a': 2},
+    )
 
   def test_promote_args(self):
     """Verifies that Functions can promote and verify their arguments."""

ee/tests/image_test.py

@@ -97,6 +97,20 @@ class ImageTest(apitestcase.ApiTestCase):
         'value': 'foo'
     }, from_variable.encode(None))
 
+  def test_constructor_invalid_version(self):
+    with self.assertRaisesRegex(
+        ee_exception.EEException,
+        r'If version is specified, the arg to Image\(\) must be a string',
+    ):
+      ee.Image(123, version=456)
+
+  def test_constructor_unrecognized_type(self):
+    with self.assertRaisesRegex(
+        ee_exception.EEException,
+        'Unrecognized argument type to convert to an Image:',
+    ):
+      ee.Image({'some': 'dict'})
+
   def test_image_signatures(self):
     """Verifies that the API functions are added to ee.Image."""
     self.assertTrue(hasattr(ee.Image(1), 'addBands'))
@@ -629,6 +643,19 @@ class CloudThumbnailAndExportImageTest(apitestcase.ApiTestCase):
       )
       self.assertEqual({}, params)
 
+  def test_prepare_for_export_with_crs_and_crsTransform(self):
+    with apitestcase.UsingCloudApi():
+      image, params = self._base_image.prepare_for_export(
+          {'crs': 'ABCD', 'crsTransform': '1,2,3,4,5,6'}
+      )
+      self.assertImageEqual(
+          self._base_image.reproject(
+              crs='ABCD', crsTransform=[1, 2, 3, 4, 5, 6]
+          ),
+          image,
+      )
+      self.assertEqual({}, params)
+
   def test_prepare_for_export_invalid_crs_and_transform(self):
     with apitestcase.UsingCloudApi():
       with self.assertRaises(ee_exception.EEException):
@@ -637,6 +664,20 @@ class CloudThumbnailAndExportImageTest(apitestcase.ApiTestCase):
         self._base_image.prepare_for_export(
             {'crs': 'ABCD', 'crs_transform': 'x'}
         )
+      with self.assertRaisesRegex(
+          ee_exception.EEException,
+          'Both "crs_transform" and "crsTransform" are specified.',
+      ):
+        self._base_image.prepare_for_export({
+            'crs': 'EPSG:4326',
+            'crs_transform': [1, 2, 3, 4, 5, 6],
+            'crsTransform': [1, 2, 3, 4, 5, 6],
+        })
+
+  def test_prepare_for_export_invalid_dimensions(self):
+    with apitestcase.UsingCloudApi():
+      with self.assertRaisesRegex(ee_exception.EEException, 'Invalid dimensions'):
+        self._base_image.prepare_for_export({'dimensions': [1, 2, 3]})
 
   def test_prepare_for_export_with_polygon(self):
     with apitestcase.UsingCloudApi():

ee/tests/imagecollection_test.py

@@ -84,6 +84,13 @@ class ImageCollectionTest(apitestcase.ApiTestCase):
         ee.ComputedObject(None, {'x': 'y'}))
     self.assertEqual({'x': 'y'}, from_computed_object.args)
 
+  def test_unrecognized_type(self):
+    with self.assertRaisesRegex(
+        ee.EEException,
+        'Unrecognized argument type to convert to an ImageCollection: 123',
+    ):
+      ee.ImageCollection(123)
+
   def test_imperative_functions(self):
     """Verifies that imperative functions return ready values."""
     image_collection = ee.ImageCollection(ee.Image(1))
@@ -135,6 +142,18 @@ class ImageCollectionTest(apitestcase.ApiTestCase):
           collection.serialize(for_cloud_api=True))
       self.assertEqual({}, params)
 
+  def test_filmstrip_thumb_url_invalid_format(self):
+    """Verifies correct thumbnailing behavior."""
+    message = r'Invalid format specified for thumbnail\. gif'
+    with self.assertRaisesRegex(ee.EEException, message):
+      ee.ImageCollection(ee.Image(1)).getFilmstripThumbURL({'format': 'gif'})
+
+  def test_video_thumb_url_invalid_format(self):
+    """Verifies correct thumbnailing behavior."""
+    message = r'Invalid format specified for thumbnail\. png'
+    with self.assertRaisesRegex(ee.EEException, message):
+      ee.ImageCollection(ee.Image(1)).getVideoThumbURL({'format': 'png'})
+
   def test_select_opt_params(self):
     result = (
         ee.ImageCollection([])
@@ -143,6 +162,56 @@ class ImageCollectionTest(apitestcase.ApiTestCase):
     )
     self.assertIn('"newNames": {"constantValue": ["name_a", "name_b"]}', result)
 
+  def test_link_collection_all_args(self):
+    image_collection_1 = ee.ImageCollection('a')
+    image_collection_2 = ee.ImageCollection('b')
+    linked_bands = ['b1', 'b2']
+    linked_properties = ['p1', 'p2']
+    match_property_name = 'p3'
+    result = image_collection_1.linkCollection(
+        image_collection_2,
+        linked_bands,
+        linked_properties,
+        match_property_name,
+    )
+    self.assertIsInstance(result, ee.ImageCollection)
+    self.assertEqual(ee.ApiFunction.lookup('Collection.map'), result.func)
+    self.assertEqual(image_collection_1, result.args['collection'])
+    self.assertIsInstance(result.args['baseAlgorithm'], ee.Function)
+
+    serialized = result.serialize()
+    self.assertIn('"functionName": "ImageCollection.load"', serialized)
+    self.assertIn('"id": {"constantValue": "a"}', serialized)
+    self.assertIn('"functionName": "Image.linkCollection"', serialized)
+    self.assertIn('"id": {"constantValue": "b"}', serialized)
+    self.assertIn('"linkedBands": {"constantValue": ["b1", "b2"]}', serialized)
+    self.assertIn(
+        '"linkedProperties": {"constantValue": ["p1", "p2"]}', serialized
+    )
+    self.assertIn('"matchPropertyName": {"constantValue": "p3"}', serialized)
+
+  def test_link_collection_necessary_args(self):
+    image_collection_1 = ee.ImageCollection('a')
+    image_collection_2 = ee.ImageCollection('b')
+    linked_bands = ['b1', 'b2']
+    result = image_collection_1.linkCollection(
+        image_collection_2,
+        linkedBands=linked_bands,
+    )
+    self.assertIsInstance(result, ee.ImageCollection)
+    self.assertEqual(ee.ApiFunction.lookup('Collection.map'), result.func)
+    self.assertEqual(image_collection_1, result.args['collection'])
+    self.assertIsInstance(result.args['baseAlgorithm'], ee.Function)
+
+    serialized = result.serialize()
+    self.assertIn('"functionName": "ImageCollection.load"', serialized)
+    self.assertIn('"id": {"constantValue": "a"}', serialized)
+    self.assertIn('"functionName": "Image.linkCollection"', serialized)
+    self.assertIn('"id": {"constantValue": "b"}', serialized)
+    self.assertIn('"linkedBands": {"constantValue": ["b1", "b2"]}', serialized)
+    self.assertNotIn('"linkedProperties"', serialized)
+    self.assertNotIn('"matchPropertyName"', serialized)
+
   def test_aggregate_array(self):
     property_name = 'property name'
     expect = make_expression_graph({

ee/tests/join_test.py

@@ -28,6 +28,11 @@ class JoinTest(apitestcase.ApiTestCase):
     with self.assertRaisesRegex(TypeError, message):
       ee.Join()  # pytype:disable=missing-parameter
 
+  def test_join_type_error(self):
+    message = r"Join can only be used as a cast to Join\. Found <class 'str'>"
+    with self.assertRaisesRegex(TypeError, message):
+      ee.Join('some string')  # pytype:disable=wrong-arg-types
+
   def test_apply(self):
     expect = make_expression_graph({
         'arguments': {