earthengine-api 1.7.1rc0__py3-none-any.whl → 1.7.2rc0__py3-none-any.whl

{earthengine_api-1.7.1rc0.dist-info → earthengine_api-1.7.2rc0.dist-info}/METADATA

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

{earthengine_api-1.7.1rc0.dist-info → earthengine_api-1.7.2rc0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-earthengine_api-1.7.1rc0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ee/__init__.py,sha256=lEC4bIEery_yxWS6Jxd3JxS747fGhDQlXCAdAle3QCE,16761
+earthengine_api-1.7.2rc0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ee/__init__.py,sha256=qXFqyr1frW_X1pYT3uUOMUT6rvGLGcCNejHvZ_g-VQI,16761
 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=Q15duH7_O2gjIlDanmjien5z8ZZRuooyhNivUpXbM6E,85370
+ee/data.py,sha256=TmtDZZXVJxKOVPNSabQ9DxtYALn1BXUHiZJKXzVL6w4,85371
 ee/daterange.py,sha256=nrRYkR2M2aVU0ZJyG7yiZStFt-W2TvYVuazoZK_WZqM,4948
 ee/deprecation.py,sha256=mAFdO7fBjOu9TJd8CJB_M_NsZ6VNSxtSe820QKJx8fE,6243
 ee/deserializer.py,sha256=TjhQjcBnFpz8Kodoj74eSbvkJ2zLjpTTfUpcNEoQR2o,8357
@@ -42,7 +42,7 @@ ee/join.py,sha256=idnuzRNFvKHRLHV5m9unp_xTsZb-E2kfgUCEYSg64ts,7578
 ee/kernel.py,sha256=eTzJFvW4nbyiFl2dDZ0_cA_o3KqCbBewY-BDp7tCB_M,15002
 ee/mapclient.py,sha256=feCFwL76juFFZPI4uycVxUoFMeEFbPFfIVETkmpvmcY,17491
 ee/model.py,sha256=ZLBT0bdo16V_fSR3eqVxvEmkpGGqMdqYBVZTwOAXvcU,12069
-ee/oauth.py,sha256=gqm2nUIAk_PN9yJes1Yy8eLzQ8vvPapZPOY05BVRvOY,22118
+ee/oauth.py,sha256=i2R56YDJwC9A1Wpf9MOz-01L4PYoHvuIs0TnCpjlLxU,22194
 ee/pixeltype.py,sha256=ucUwJ5SvcOT849Ap4mlJL9z11IAbcT1w9ii8-zOoqdI,5196
 ee/projection.py,sha256=n7WvMeYEG9zksGN1tIX7RGweC4IyCrXAKsvPY0e2b8k,5868
 ee/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -69,7 +69,7 @@ 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=YyVh891MuLeDWx5Fj_uGHvpudy73E8cu1BhR1G-mlWA,40391
+ee/tests/data_test.py,sha256=8oiSnzGoOtWx3YIld8owWYw1zC517uLkq1Uf2Xn4iCI,52063
 ee/tests/daterange_test.py,sha256=a5fpg2lko3kCJzxQPCoAc_vjXkKy2zYcXbeSZKAFovI,8583
 ee/tests/deprecation_test.py,sha256=CoVug7J9YdB2utZ-BikyJcjitYPQLz49JL_z89xuQSQ,8484
 ee/tests/deserializer_test.py,sha256=i_tlyzKgCo1-VpWPAQnTWNcr2klourcMcBbFZJN6Ivw,5050
@@ -95,15 +95,15 @@ ee/tests/imagecollection_test.py,sha256=qosRZXCbhwFuy8qR7DbA-FMl4ktW7Y2cUJHeXLcs
 ee/tests/join_test.py,sha256=pFILq3qM27rO64WYbBC1A_Gs8_pabRv68X7MU_EM_cw,7630
 ee/tests/kernel_test.py,sha256=-0nZVNSxE1IGs4y60oijISh2Hi1V7NCjrmUnEMDd0nQ,19378
 ee/tests/model_test.py,sha256=dgnWfqR4R4MIUljMBL1TOcztzA-lWEl7cT5f2Y0k2ck,12483
-ee/tests/oauth_test.py,sha256=jYFw8GWPFmLR0jh2NvbcrMizQo_qR_bRDBVRdIZ44g0,3067
+ee/tests/oauth_test.py,sha256=8hldNiR3AYtQkWA4vwwSAO6jDIsh_fww7b_cOI9MJjo,9202
 ee/tests/pixeltype_test.py,sha256=00IWKnZ7xxkVwSSCuWOlCwlTsHAb3XPyKp1Arc4S12U,10024
 ee/tests/projection_test.py,sha256=fKXXxQPBvWdlMNtNsJze2pbsT0yHHlL7ON8Pdjm1Z7E,6871
 ee/tests/reducer_test.py,sha256=vqXpgLZ7fPyfZ12srpREgMpfrKYLcFQod3Qn1Niv7VM,31979
 ee/tests/serializer_test.py,sha256=d6IEW_dt-G900IRfQnZftrwjpc1wJ-ouaQQwaLO0FxI,9834
-ee/tests/table_converter_test.py,sha256=KubC_IY4SpXkpEwvisplI1KQgLzHFOfxKepGgcZCoLg,3360
+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.1rc0.dist-info/METADATA,sha256=GftU4XD7nkekpNSU0z0HEjXITendLIN3FwB2q-POkwY,2147
-earthengine_api-1.7.1rc0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-earthengine_api-1.7.1rc0.dist-info/entry_points.txt,sha256=-Ax4SCU-S474r8OD2LIxata6PRmkZoDrppQ4fP_exNc,50
-earthengine_api-1.7.1rc0.dist-info/top_level.txt,sha256=go5zOwCgm5lIS3yTR-Vsxp1gNI4qdS-MP5eY-7zMxVY,3
-earthengine_api-1.7.1rc0.dist-info/RECORD,,
+earthengine_api-1.7.2rc0.dist-info/METADATA,sha256=-fSFJkm8cxCurqIIWXyR5FNsmKOb8LaI72q9K7fqf2k,2147
+earthengine_api-1.7.2rc0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+earthengine_api-1.7.2rc0.dist-info/entry_points.txt,sha256=-Ax4SCU-S474r8OD2LIxata6PRmkZoDrppQ4fP_exNc,50
+earthengine_api-1.7.2rc0.dist-info/top_level.txt,sha256=go5zOwCgm5lIS3yTR-Vsxp1gNI4qdS-MP5eY-7zMxVY,3
+earthengine_api-1.7.2rc0.dist-info/RECORD,,

ee/__init__.py

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

ee/data.py

@@ -2161,6 +2161,7 @@ def setIamPolicy(asset_id: str, policy: Any) -> None:
       .setIamPolicy(resource=name, body={'policy': policy}, prettyPrint=False)
   )
 
+
 @deprecation.Deprecated('Use ee.data.updateAsset().')
 def setAssetProperties(assetId: str, properties: dict[str, Any]) -> None:
   """Sets metadata properties of the asset with the given ID.

ee/oauth.py

@@ -226,7 +226,7 @@ def _in_jupyter_shell() -> bool:
   """Tests if the code is being executed within Jupyter."""
   try:
     import ipykernel.zmqshell
-    return isinstance(IPython.get_ipython(),
+    return isinstance(IPython.get_ipython(),  # pylint: disable=undefined-variable
                       ipykernel.zmqshell.ZMQInteractiveShell)
   except ImportError:
     return False
@@ -329,7 +329,7 @@ def _display_auth_instructions_with_html(
 ) -> None:
   """Displays instructions for authenticating using HTML code."""
   try:
-    IPython.display.display(IPython.display.HTML(
+    IPython.display.display(IPython.display.HTML(  # pylint: disable=undefined-variable
         """<p>To authorize access needed by Earth Engine, open the following
         URL in a web browser and follow the instructions:</p>
         <p><a href={0}>{0}</a></p>

ee/tests/data_test.py

@@ -87,6 +87,26 @@ class DataTest(unittest.TestCase):
         _state.get_state().cloud_api_user_project, 'earthengine-legacy'
     )
 
+  @mock.patch.object(ee.data, '_install_cloud_api_resource', return_value=None)
+  def test_initialize_with_credentials(
+      self, unused_mock_install_cloud_api_resource
+  ):
+    creds = mock.MagicMock()
+    ee.data.initialize(credentials=creds)
+
+    self.assertTrue(ee.data.is_initialized())
+    self.assertEqual(creds, _state.get_state().credentials)
+
+  @mock.patch.object(ee.data, '_install_cloud_api_resource', return_value=None)
+  def test_initialize_with_cloud_api_key(
+      self, unused_mock_install_cloud_api_resource
+  ):
+    cloud_api_key = 'a cloud api key'
+    ee.data.initialize(cloud_api_key=cloud_api_key)
+
+    self.assertTrue(ee.data.is_initialized())
+    self.assertEqual(cloud_api_key, _state.get_state().cloud_api_key)
+
   def test_set_max_retries_bad_values(self):
     with self.assertRaises(ValueError):
       ee.data.setMaxRetries(-1)
@@ -110,6 +130,46 @@ class DataTest(unittest.TestCase):
           .execute.call_args.kwargs['num_retries'],
       )
 
+  def test_set_cloud_api_key(self):
+    cloud_api_key = 'a cloud api key'
+    with mock.patch.object(
+        ee.data, '_install_cloud_api_resource', return_value=None
+    ) as mock_install_cloud_api_resource:
+      ee.data.setCloudApiKey(cloud_api_key)
+      self.assertEqual(cloud_api_key, _state.get_state().cloud_api_key)
+      mock_install_cloud_api_resource.assert_called_once()
+
+  def test_set_deadline(self):
+    deadline_ms = 12345
+    with mock.patch.object(
+        ee.data, '_install_cloud_api_resource', return_value=None
+    ) as mock_install_cloud_api_resource:
+      ee.data.setDeadline(deadline_ms)
+      self.assertEqual(deadline_ms, _state.get_state().deadline_ms)
+      mock_install_cloud_api_resource.assert_called_once()
+
+  def test_get_set_user_agent(self):
+    self.assertIsNone(ee.data.getUserAgent())
+    user_agent = 'user-agent'
+    ee.data.setUserAgent(user_agent)
+    self.assertEqual(user_agent, ee.data.getUserAgent())
+
+  def test_authorize_http_no_credentials(self):
+    self.assertIsNone(ee.data._get_state().credentials)
+    http = mock.MagicMock()
+    self.assertEqual(http, ee.data.authorizeHttp(http))
+
+  def test_authorize_http_with_credentials(self):
+    creds = mock.MagicMock()
+    ee.data._get_state().credentials = creds
+    http = mock.MagicMock()
+    with mock.patch.object(
+        ee.data.google_auth_httplib2, 'AuthorizedHttp'
+    ) as mock_authorized_http:
+      result = ee.data.authorizeHttp(http)
+      self.assertEqual(mock_authorized_http.return_value, result)
+      mock_authorized_http.assert_called_once_with(creds)
+
   def test_list_operations(self):
     mock_http = mock.MagicMock(httplib2.Http)
     # Return in three groups.
@@ -342,6 +402,14 @@ class DataTest(unittest.TestCase):
       asset = mock_create_asset.call_args.kwargs['body']
       self.assertEqual(asset, {'type': 'FOLDER'})
 
+  @mock.patch.object(ee.data, 'createAsset')
+  def test_create_asset_home(self, mock_create_asset):
+    ee.data.createAssetHome('users/test')
+    mock_create_asset.assert_called_once_with({
+        'name': 'projects/earthengine-legacy/assets/users/test',
+        'type': 'FOLDER',
+    })
+
   def test_create_assets(self):
     cloud_api_resource = mock.MagicMock()
     with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
@@ -432,6 +500,68 @@ class DataTest(unittest.TestCase):
       )
       self.assertTrue(import_args['overwrite'])
 
+  def test_start_table_ingestion(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      mock_result = {'name': 'operations/ingestion', 'done': False}
+      cloud_api_resource.projects().table().import_.return_value.execute.return_value = (
+          mock_result
+      )
+      params = {
+          'id': 'users/test/table',
+          'sources': [{'uris': ['gs://bucket/file.shp'], 'charset': 'UTF-8'}],
+      }
+      result = ee.data.startTableIngestion('request_id', params, True)
+      self.assertEqual(result['id'], 'ingestion')
+      self.assertEqual(result['name'], 'operations/ingestion')
+
+      mock_import = cloud_api_resource.projects().table().import_
+      mock_import.assert_called_once()
+      call_kwargs = mock_import.call_args.kwargs
+      self.assertEqual(call_kwargs['project'], 'projects/earthengine-legacy')
+      body = call_kwargs['body']
+      self.assertEqual(
+          body['tableManifest'],
+          {
+              'name': 'projects/earthengine-legacy/assets/users/test/table',
+              'sources': [
+                  {'uris': ['gs://bucket/file.shp'], 'charset': 'UTF-8'}
+              ],
+          },
+      )
+      self.assertEqual(body['requestId'], 'request_id')
+      self.assertTrue(body['overwrite'])
+
+  def test_start_external_image_ingestion(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      cloud_api_resource.projects().image().importExternal.return_value.execute.return_value = (
+          {}
+      )
+      manifest = {
+          'id': 'users/test/image',
+          'tilesets': [{'sources': [{'uris': ['gs://bucket/file.tif']}]}],
+      }
+      result = ee.data.startExternalImageIngestion(manifest, True)
+      expected_name = 'projects/earthengine-legacy/assets/users/test/image'
+      self.assertEqual(result['name'], expected_name)
+
+      mock_import_external = (
+          cloud_api_resource.projects().image().importExternal
+      )
+      mock_import_external.assert_called_once()
+      call_kwargs = mock_import_external.call_args.kwargs
+      self.assertEqual(call_kwargs['project'], 'projects/earthengine-legacy')
+      body = call_kwargs['body']
+      self.assertEqual(
+          body['imageManifest'],
+          {
+              'name': expected_name,
+              'tilesets': [{'sources': [{'uris': ['gs://bucket/file.tif']}]}],
+          },
+      )
+      self.assertTrue(body['overwrite'])
+
   def test_set_asset_properties(self):
     mock_http = mock.MagicMock(httplib2.Http)
     with apitestcase.UsingCloudApi(mock_http=mock_http), mock.patch.object(
@@ -453,6 +583,18 @@ class DataTest(unittest.TestCase):
           {'properties.\"mYPropErTy\"',
                'properties.\"system:time_start\"'})
 
+  def test_update_asset(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      asset_id = 'users/test/asset'
+      asset = {'properties': {'foo': 'bar'}}
+      update_mask = ['properties.foo']
+      ee.data.updateAsset(asset_id, asset, update_mask)
+      cloud_api_resource.projects().assets().patch.assert_called_once_with(
+          name='projects/earthengine-legacy/assets/users/test/asset',
+          body={'updateMask': {'paths': update_mask}, 'asset': asset},
+      )
+
   def test_list_assets(self):
     cloud_api_resource = mock.MagicMock()
     with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
@@ -576,6 +718,16 @@ class DataTest(unittest.TestCase):
     cloud_api_resource.projects().listAssets().execute.assert_called_once()
     self.assertEqual(mock_result, actual_result)
 
+  def test_get_asset_roots(self):
+    with mock.patch.object(
+        ee.data,
+        'listBuckets',
+        return_value={'assets': [{'name': 'id1', 'type': 'FOLDER'}]},
+    ) as mock_list_buckets:
+      result = ee.data.getAssetRoots()
+      mock_list_buckets.assert_called_once()
+      self.assertEqual([{'id': 'id1', 'type': 'Folder'}], result)
+
   def test_simple_get_list_via_cloud_api(self):
     cloud_api_resource = mock.MagicMock()
     with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
@@ -881,6 +1033,50 @@ class DataTest(unittest.TestCase):
       ).execute.assert_called_once()
       self.assertEqual(mock_result, actual_result)
 
+  def test_get_pixels(self):
+    cloud_api_resource_raw = mock.MagicMock()
+    with apitestcase.UsingCloudApi(
+        cloud_api_resource_raw=cloud_api_resource_raw
+    ):
+      assets = cloud_api_resource_raw.projects().assets()
+      mock_result = b'pixel data'
+      assets.getPixels.return_value.execute.return_value = mock_result
+      asset_id = 'users/foo/bar'
+      params = {'assetId': asset_id}
+      result = ee.data.getPixels(params)
+      self.assertEqual(mock_result, result)
+      assets.getPixels.assert_called_once_with(
+          name='projects/earthengine-legacy/assets/users/foo/bar',
+          body={'fileFormat': 'AUTO_JPEG_PNG'},
+      )
+
+  def test_compute_pixels(self):
+    cloud_api_resource_raw = mock.MagicMock()
+    with apitestcase.UsingCloudApi(
+        cloud_api_resource_raw=cloud_api_resource_raw
+    ):
+      mock_result = b'pixel data'
+      (
+          cloud_api_resource_raw.projects()
+          .image()
+          .computePixels.return_value.execute.return_value
+      ) = mock_result
+      expression = ee.Image(1)
+      params = {'expression': expression}
+      result = ee.data.computePixels(params)
+      self.assertEqual(mock_result, result)
+      (
+          cloud_api_resource_raw.projects()
+          .image()
+          .computePixels.assert_called_once_with(
+              project='projects/earthengine-legacy',
+              body={
+                  'expression': ee.serializer.encode(expression),
+                  'fileFormat': 'AUTO_JPEG_PNG',
+              },
+          )
+      )
+
   def test_get_feature_view_tiles_key(self):
     cloud_api_resource = mock.MagicMock()
     _state.get_state().tile_base_url = 'base_url'
@@ -922,8 +1118,31 @@ class DataTest(unittest.TestCase):
       cloud_api_resource.projects().updateConfig().execute.return_value = (
           mock_result
       )
+      project_config = {'maxConcurrentExports': 2}
       actual_result = ee.data.updateProjectConfig(
-          {'maxConcurrentExports': 2}, ['max_concurrent_exports']
+          project_config, ['max_concurrent_exports']
+      )
+      cloud_api_resource.projects().updateConfig.assert_called_with(
+          name='projects/earthengine-legacy/config',
+          body=project_config,
+          updateMask='max_concurrent_exports',
+      )
+      cloud_api_resource.projects().updateConfig().execute.assert_called_once()
+      self.assertEqual(mock_result, actual_result)
+
+  def test_update_project_config_no_mask(self) -> None:
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      mock_result = {'fake-project-config-value': 1}
+      cloud_api_resource.projects().updateConfig().execute.return_value = (
+          mock_result
+      )
+      project_config = {'maxConcurrentExports': 2}
+      actual_result = ee.data.updateProjectConfig(project_config)
+      cloud_api_resource.projects().updateConfig.assert_called_with(
+          name='projects/earthengine-legacy/config',
+          body=project_config,
+          updateMask='max_concurrent_exports',
       )
       cloud_api_resource.projects().updateConfig().execute.assert_called_once()
       self.assertEqual(mock_result, actual_result)
@@ -1040,6 +1259,81 @@ class DataTest(unittest.TestCase):
       }
       self.assertEqual(expected, quota)
 
+  def test_get_asset_root_quota_not_root(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      asset_id = 'users/test/asset'
+      fake_asset = {
+          'type': 'IMAGE',
+          'name': 'projects/earthengine-legacy/assets/users/test/asset',
+      }
+      cloud_api_resource.projects().assets().get().execute.return_value = (
+          fake_asset
+      )
+      with self.assertRaisesRegex(
+          ee.ee_exception.EEException, f'{asset_id} is not a root folder.'
+      ):
+        ee.data.getAssetRootQuota(asset_id)
+
+  def test_get_iam_policy(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      asset_id = 'users/test/asset'
+      ee.data.getIamPolicy(asset_id)
+      cloud_api_resource.projects().assets().getIamPolicy.assert_called_once_with(
+          resource='projects/earthengine-legacy/assets/users/test/asset',
+          body={},
+          prettyPrint=False,
+      )
+
+  def test_get_asset_acl(self):
+    asset_id = 'users/test/asset'
+    policy = {'bindings': [{'role': 'roles/viewer', 'members': ['allUsers']}]}
+    acl = {'readers': ['allUsers']}
+    with mock.patch.object(
+        ee.data, 'getIamPolicy', return_value=policy
+    ) as mock_get_iam_policy, mock.patch.object(
+        ee.data._cloud_api_utils, 'convert_iam_policy_to_acl', return_value=acl
+    ) as mock_convert:
+      result = ee.data.getAssetAcl(asset_id)
+      mock_get_iam_policy.assert_called_once_with(asset_id)
+      mock_convert.assert_called_once_with(policy)
+      self.assertEqual(acl, result)
+
+  def test_set_asset_acl(self):
+    asset_id = 'users/test/asset'
+    acl_update_dict = {'readers': ['allUsers']}
+    acl_update_str = '{"readers": ["allUsers"]}'
+    policy = {'bindings': [{'role': 'roles/viewer', 'members': ['allUsers']}]}
+    with mock.patch.object(
+        ee.data._cloud_api_utils,
+        'convert_acl_to_iam_policy',
+        return_value=policy,
+    ) as mock_convert, mock.patch.object(
+        ee.data, 'setIamPolicy'
+    ) as mock_set_iam_policy:
+      ee.data.setAssetAcl(asset_id, acl_update_dict)
+      mock_convert.assert_called_once_with(acl_update_dict)
+      mock_set_iam_policy.assert_called_once_with(asset_id, policy)
+
+      mock_convert.reset_mock()
+      mock_set_iam_policy.reset_mock()
+      ee.data.setAssetAcl(asset_id, acl_update_str)
+      mock_convert.assert_called_once_with(acl_update_dict)
+      mock_set_iam_policy.assert_called_once_with(asset_id, policy)
+
+  def test_set_iam_policy(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      asset_id = 'users/test/asset'
+      policy = {'bindings': [{'role': 'roles/viewer', 'members': ['allUsers']}]}
+      ee.data.setIamPolicy(asset_id, policy)
+      cloud_api_resource.projects().assets().setIamPolicy.assert_called_once_with(
+          resource='projects/earthengine-legacy/assets/users/test/asset',
+          body={'policy': policy},
+          prettyPrint=False,
+      )
+
 
 def DoCloudProfileStubHttp(test, expect_profiling):
 

ee/tests/oauth_test.py

@@ -1,6 +1,8 @@
 #!/usr/bin/env python3
 """Test for the oauth module."""
 
+import http.client
+import io
 import json
 import sys
 import tempfile
@@ -34,20 +36,33 @@ class OAuthTest(unittest.TestCase):
       self.assertEqual('xyz', parsed[b'code_verifier'][0].decode())
       return MockResponse(parsed[b'code'][0])
 
-    with mock.patch('urllib.request.urlopen', new=mock_urlopen):
+    with mock.patch.object(urllib.request, 'urlopen', new=mock_urlopen):
       auth_code = '123'
       verifier = 'xyz'
       refresh_token = oauth.request_token(auth_code, verifier)
       self.assertEqual('123456', refresh_token)
 
+  def test_request_token_http_error(self):
+    mock_fp = io.BytesIO(b'error details')
+    http_error = urllib.error.HTTPError(
+        'url', 400, 'message', hdrs=http.client.HTTPMessage(), fp=mock_fp
+    )
+    with mock.patch.object(urllib.request, 'urlopen', side_effect=http_error):
+      with self.assertRaisesRegex(
+          Exception,
+          r"Problem requesting tokens.*HTTP Error 400: message.*b'error"
+          r" details'",
+      ):
+        oauth.request_token('auth_code', 'code_verifier')
+
   def test_write_token(self):
 
     def mock_credentials_path():
-      return self.test_tmpdir + '/tempfile'
+      return f'{self.test_tmpdir}/tempfile'
 
-    oauth_pkg = 'ee.oauth'
-    with mock.patch(
-        oauth_pkg + '.get_credentials_path', new=mock_credentials_path):
+    with mock.patch.object(
+        oauth, 'get_credentials_path', new=mock_credentials_path
+    ):
       client_info = dict(refresh_token='123')
       oauth.write_private_json(oauth.get_credentials_path(), client_info)
 
@@ -55,6 +70,46 @@ class OAuthTest(unittest.TestCase):
       token = json.load(f)
       self.assertEqual({'refresh_token': '123'}, token)
 
+  def test_get_credentials_arguments(self):
+    credentials_path = f'{self.test_tmpdir}/temp_creds'
+
+    creds = {
+        'refresh_token': 'REFRESH_TOKEN',
+        'client_id': 'CLIENT_ID',
+        'project': 'PROJECT',
+    }
+    with open(credentials_path, 'w') as f:
+      json.dump(creds, f)
+
+    with mock.patch.object(
+        oauth, 'get_credentials_path', return_value=credentials_path
+    ):
+      args = oauth.get_credentials_arguments()
+
+    expected_args = {
+        'token_uri': oauth.TOKEN_URI,
+        'refresh_token': 'REFRESH_TOKEN',
+        'client_id': 'CLIENT_ID',
+        'client_secret': oauth.CLIENT_SECRET,
+        'scopes': oauth.SCOPES,
+        'quota_project_id': 'PROJECT',
+    }
+    self.assertEqual(expected_args, args)
+
+  def test_is_valid_credentials(self):
+    self.assertFalse(oauth.is_valid_credentials(None))
+
+    mock_credentials_valid = mock.MagicMock()
+    self.assertTrue(oauth.is_valid_credentials(mock_credentials_valid))
+    mock_credentials_valid.refresh.assert_called_once()
+
+    mock_credentials_invalid = mock.MagicMock()
+    mock_credentials_invalid.refresh.side_effect = (
+        oauth.google.auth.exceptions.RefreshError()
+    )
+    self.assertFalse(oauth.is_valid_credentials(mock_credentials_invalid))
+    mock_credentials_invalid.refresh.assert_called_once()
+
   def test_in_colab_shell(self):
     with mock.patch.dict(sys.modules, {'google.colab': None}):
       self.assertFalse(oauth.in_colab_shell())
@@ -78,7 +133,7 @@ class OAuthTest(unittest.TestCase):
         )
     )
 
-  def testAuthenticate_colabAuthModeWithNonstandardScopes_raisesException(self):
+  def test_colab_mode_with_nonstandard_scopes_raises_exception(self):
     with self.assertRaisesRegex(
         ee_exception.EEException,
         'Scopes cannot be customized when auth_mode is "colab".'
@@ -88,7 +143,7 @@ class OAuthTest(unittest.TestCase):
           scopes=['https://www.googleapis.com/auth/earthengine.readonly']
       )
 
-  def testAuthenticate_colabAuthModeWithStandardScopes_succeeds(self):
+  def test_colab_auth_mode_with_standard_scopes_succeeds(self):
     # Should not raise an exception if the scopes are not narrowed.
     with mock.patch.dict(sys.modules, {'google.colab': mock.MagicMock()}):
       try:
@@ -96,5 +151,113 @@ class OAuthTest(unittest.TestCase):
       except ee_exception.EEException:
         self.fail('authenticate raised an exception unexpectedly.')
 
+  def test_authenticate_appdefault(self):
+    with mock.patch.object(
+        oauth,
+        '_valid_credentials_exist',
+        return_value=False,
+    ), mock.patch.object(
+        sys, 'stderr', new_callable=io.StringIO
+    ) as mock_stderr:
+      oauth.authenticate(auth_mode='appdefault')
+      self.assertIn('appdefault no longer necessary', mock_stderr.getvalue())
+
+  @mock.patch.object(oauth, '_load_gcloud_credentials')
+  @mock.patch.object(oauth, '_valid_credentials_exist', return_value=False)
+  @mock.patch.object(oauth, 'in_colab_shell', return_value=False)
+  @mock.patch.object(oauth, '_in_jupyter_shell', return_value=False)
+  @mock.patch.object(oauth, '_localhost_is_viable', return_value=False)
+  def test_authenticate_default_gcloud(
+      self,
+      mock_localhost_viable,
+      mock_jupyter,
+      mock_colab,
+      mock_valid_creds,
+      mock_load_gcloud,
+  ):
+    del (
+        mock_localhost_viable,
+        mock_jupyter,
+        mock_colab,
+        mock_valid_creds,
+    )  # Unused
+    oauth.authenticate()
+    mock_load_gcloud.assert_called_once_with(None, None, False)
+
+  def test_localhost_fetch_code(self):
+    mock_server = mock.MagicMock()
+    mock_server.url = 'http://localhost:8085'
+    mock_server.fetch_code.return_value = 'FETCHED_CODE'
+    with mock.patch.object(
+        oauth, '_start_server', return_value=mock_server
+    ), mock.patch.object(oauth, '_obtain_and_write_token') as mock_obtain:
+      flow = oauth.Flow(auth_mode='localhost')
+      flow.save_code()
+      mock_server.fetch_code.assert_called_once()
+      mock_obtain.assert_called_once_with(
+          'FETCHED_CODE',
+          flow.code_verifier,
+          flow.scopes,
+          'http://localhost:8085',
+      )
+
+  @mock.patch.object(oauth, '_display_auth_instructions_for_noninteractive')
+  def test_display_instructions_quiet(self, mock_display):
+    flow = oauth.Flow(auth_mode='notebook')
+    self.assertTrue(flow.display_instructions(quiet=True))
+    mock_display.assert_called_once_with(flow.auth_url, flow.code_verifier)
+
+  @mock.patch.object(oauth, '_display_auth_instructions_with_print')
+  @mock.patch.object(oauth, 'in_colab_shell', return_value=True)
+  def test_display_instructions_colab(self, mock_in_colab, mock_display_print):
+    del mock_in_colab  # Unused
+    flow = oauth.Flow(auth_mode='notebook')
+    self.assertTrue(flow.display_instructions())
+    mock_display_print.assert_called_once_with(flow.auth_url, None)
+
+  @mock.patch.object(oauth, '_display_auth_instructions_with_html')
+  @mock.patch.object(oauth, '_in_jupyter_shell', return_value=True)
+  def test_display_instructions_jupyter(
+      self, mock_in_jupyter, mock_display_html
+  ):
+    del mock_in_jupyter  # Unused
+    flow = oauth.Flow(auth_mode='notebook')
+    self.assertTrue(flow.display_instructions())
+    mock_display_html.assert_called_once_with(flow.auth_url, None)
+
+  @mock.patch.object(oauth, '_display_auth_instructions_with_print')
+  @mock.patch.object(oauth, 'in_colab_shell', return_value=False)
+  @mock.patch.object(oauth, '_in_jupyter_shell', return_value=False)
+  def test_display_instructions_print(
+      self, mock_in_jupyter, mock_in_colab, mock_display_print
+  ):
+    del mock_in_jupyter, mock_in_colab  # Unused
+    flow = oauth.Flow(auth_mode='notebook')
+    self.assertTrue(flow.display_instructions())
+    mock_display_print.assert_called_once_with(flow.auth_url, None)
+
+  @mock.patch.object(oauth, '_display_auth_instructions_with_print')
+  @mock.patch.object(oauth, 'in_colab_shell', return_value=True)
+  @mock.patch.object(oauth.http.server, 'HTTPServer')
+  def test_display_instructions_localhost_colab(
+      self, mock_http_server, mock_in_colab, mock_display_print
+  ):
+    del mock_http_server, mock_in_colab  # Unused
+    flow = oauth.Flow(auth_mode='localhost')
+    self.assertTrue(flow.display_instructions())
+    mock_display_print.assert_called_once_with(
+        flow.auth_url, oauth.WAITING_CODA
+    )
+
+  def test_flow_unknown_auth_mode(self):
+    with self.assertRaisesRegex(ee_exception.EEException, 'Unknown auth_mode'):
+      oauth.Flow(auth_mode='unknown')
+
+  def test_flow_localhost_with_port(self):
+    with mock.patch.object(oauth, '_start_server') as mock_start_server:
+      oauth.Flow(auth_mode='localhost:1234')
+      mock_start_server.assert_called_once_with(1234)
+
+
 if __name__ == '__main__':
   unittest.main()

ee/tests/table_converter_test.py

@@ -1,7 +1,9 @@
 #!/usr/bin/env python3
 """Tests for the table_converter module."""
 
+import builtins
 from typing import Any
+from unittest import mock
 
 from absl.testing import parameterized
 import geopandas
@@ -29,7 +31,7 @@ class TableConverterTest(parameterized.TestCase):
       self,
       data_format: str,
       expected: type[table_converter.TableConverter] | None,
-  ) -> None:
+  ):
     """Verifies `from_file_format` returns the correct converter class."""
     if expected is None:
       self.assertIsNone(table_converter.from_file_format(data_format))
@@ -38,7 +40,17 @@ class TableConverterTest(parameterized.TestCase):
           table_converter.from_file_format(data_format), expected
       )
 
-  def test_pandas_converter(self) -> None:
+  def test_from_file_format_instance(self):
+    """Verifies `from_file_format` returns the same instance."""
+    converter = table_converter.PandasConverter()
+    self.assertIs(table_converter.from_file_format(converter), converter)
+
+  def test_table_converter_fails(self):
+    """Verifies `TableConverter` cannot be used for conversion."""
+    with self.assertRaises(NotImplementedError):
+      table_converter.TableConverter().do_conversion(iter([]))
+
+  def test_pandas_converter(self):
     """Verifies `PandasConverter` does the correct conversion."""
     converter = table_converter.PandasConverter()
 
@@ -69,7 +81,23 @@ class TableConverterTest(parameterized.TestCase):
         ]),
     )
 
-  def test_geopandas_converter(self) -> None:
+  def test_pandas_converter_importerror(self):
+    """Ensures ImportError is raised when pandas is not available."""
+    real_import = builtins.__import__
+
+    def mock_import(name, globals=None, locals=None, fromlist=(), level=0):
+      if name == 'pandas':
+        raise ImportError
+      return real_import(name, globals, locals, fromlist, level)
+
+    with mock.patch('builtins.__import__', mock_import):
+      converter = table_converter.PandasConverter()
+      with self.assertRaisesRegex(
+          ImportError, 'Using format PANDAS_DATAFRAME requires pandas.'
+      ):
+        converter.do_conversion(iter([]))
+
+  def test_geopandas_converter(self):
     """Verifies `GeoPandasConverter` does the correct conversion."""
     converter = table_converter.GeoPandasConverter()
 
@@ -105,6 +133,22 @@ class TableConverterTest(parameterized.TestCase):
         geopandas.GeoDataFrame.from_features(feature_coll),
     )
 
+  def test_geopandas_converter_importerror(self):
+    """Ensures ImportError is raised when geopandas is not available."""
+    real_import = builtins.__import__
+
+    def mock_import(name, globals=None, locals=None, fromlist=(), level=0):
+      if name == 'geopandas':
+        raise ImportError
+      return real_import(name, globals, locals, fromlist, level)
+
+    with mock.patch('builtins.__import__', mock_import):
+      converter = table_converter.GeoPandasConverter()
+      with self.assertRaisesRegex(
+          ImportError, 'Using format GEOPANDAS_GEODATAFRAME requires geopandas.'
+      ):
+        converter.do_conversion(iter([]))
+
 
 if __name__ == '__main__':
   unittest.main()