earthengine-api 1.6.13__py3-none-any.whl → 1.7.4__py3-none-any.whl

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/reducer_test.py

@@ -809,6 +809,19 @@ class ReducerTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
+  def test_ridge_regression_kwargs_with_lambda(self):
+    with self.assertRaisesRegex(
+        ValueError, 'lambda_ cannot be set when providing kwargs.'
+    ):
+      ee.Reducer.ridgeRegression(1, lambda_=3, **{'lambda': 4})
+
+  def test_ridge_regression_unexpected_kwargs(self):
+    with self.assertRaisesRegex(
+        ValueError,
+        r"Unexpected arguments: \['unexpected'\]\. Expected: lambda.",
+    ):
+      ee.Reducer.ridgeRegression(1, unexpected=4)
+
   def test_robust_linear_regression(self):
     num_x = 1
     num_y = 2

ee/tests/serializer_test.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
 """Test for the ee.serializer module."""
 
+from collections.abc import Callable
 import datetime
 import json
-from typing import Any, Callable, Union
+from typing import Any
 
 import unittest
 import ee
@@ -11,7 +12,7 @@ from ee import apitestcase
 from ee import serializer
 
 
-def _max_depth(x: Union[dict[str, Any], list[Any], str]) -> int:
+def _max_depth(x: dict[str, Any] | list[Any] | str) -> int:
   """Computes the maximum nesting level of some dict, list, or str."""
   if isinstance(x, dict):
     return 1 + max(_max_depth(v) for v in x.values())
@@ -284,6 +285,32 @@ class SerializerTest(apitestcase.ApiTestCase):
     self.assertIn('\n', serializer.toJSON(ee.Image(0), opt_pretty=True))
     self.assertNotIn('\n', serializer.toJSON(ee.Image(0), opt_pretty=False))
 
+  def test_datetime_serialization_legacy(self):
+    a_date = datetime.datetime(2014, 8, 10, tzinfo=datetime.timezone.utc)
+    # 1407628800000000 microseconds.
+    expected = {
+        'type': 'CompoundValue',
+        'scope': [],
+        'value': {
+            'type': 'Invocation',
+            'functionName': 'Date',
+            'arguments': {'value': 1407628800000.0},
+        },
+    }
+    self.assertEqual(expected, serializer.encode(a_date, for_cloud_api=False))
+
+  def test_single_value_no_compound(self):
+    """Verifies serialization of a single non-primitive value."""
+    self.assertEqual([1], serializer.encode([1], for_cloud_api=False))
+
+  def test_unencodable_object(self):
+    class Unencodable:
+      pass
+    with self.assertRaisesRegex(ee.EEException, 'Cannot encode object: .*'):
+      serializer.encode(Unencodable(), for_cloud_api=False)
+    with self.assertRaisesRegex(ee.EEException, 'Cannot encode object: .*'):
+      serializer.encode(Unencodable(), for_cloud_api=True)
+
 
 if __name__ == '__main__':
   unittest.main()

ee/tests/table_converter_test.py

@@ -1,7 +1,9 @@
 #!/usr/bin/env python3
 """Tests for the table_converter module."""
 
-from typing import Any, Optional
+import builtins
+from typing import Any
+from unittest import mock
 
 from absl.testing import parameterized
 import geopandas
@@ -28,8 +30,8 @@ class TableConverterTest(parameterized.TestCase):
   def test_from_file_format(
       self,
       data_format: str,
-      expected: Optional[type[table_converter.TableConverter]],
-  ) -> None:
+      expected: type[table_converter.TableConverter] | 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()

ee/tests/terrain_test.py

@@ -141,6 +141,14 @@ class TerrainTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
+  def test_init(self):
+    message = r'Terrain should not be used as an object.*'
+    with self.assertRaisesRegex(RuntimeError, message):
+      ee.Terrain()
+
+  def test_name(self):
+    self.assertEqual('Terrain', ee.Terrain.name())
+
 
 if __name__ == '__main__':
   unittest.main()