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

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

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

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

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

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

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

{earthengine_api-1.7.8rc0 → earthengine_api-1.7.9rc0}/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."""

{earthengine_api-1.7.8rc0 → earthengine_api-1.7.9rc0}/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():

{earthengine_api-1.7.8rc0 → earthengine_api-1.7.9rc0}/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({

{earthengine_api-1.7.8rc0 → earthengine_api-1.7.9rc0}/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': {

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

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