def testCast(self):
     """Verifies that decoding casts the result to the right class."""
     input_image = ee.Image(13).addBands(42)
     output = deserializer.fromJSON(serializer.toJSON(input_image))
     self.assertIsInstance(output, ee.Image)
     cloud_output = deserializer.fromCloudApiJSON(
         serializer.toJSON(input_image, for_cloud_api=True))
     self.assertIsInstance(cloud_output, ee.Image)
 def testReuse(self):
     """Verifies that decoding results can be used and re-encoded."""
     input_image = ee.Image(13)
     output = deserializer.fromJSON(serializer.toJSON(input_image))
     self.assertEqual(
         output.addBands(42).serialize(),
         input_image.addBands(42).serialize())
     cloud_output = deserializer.fromCloudApiJSON(
         serializer.toJSON(input_image, for_cloud_api=True))
     self.assertEqual(
         cloud_output.addBands(42).serialize(),
         input_image.addBands(42).serialize())
Example #3
0
 def testCloudRoundTrip(self):
     """Verifies a round trip of a comprehensive serialization case."""
     cloud_encoded = apitestcase.ENCODED_CLOUD_API_JSON_SAMPLE
     cloud_decoded = deserializer.decode(
         cloud_encoded)  # Supports both formats
     cloud_re_encoded = json.loads(
         serializer.toJSON(cloud_decoded, for_cloud_api=True))
     self.assertEqual(cloud_encoded, cloud_re_encoded)
     # Round-trip the decoded object through the legacy API
     encoded = json.loads(serializer.toJSON(cloud_decoded))
     decoded = deserializer.decode(encoded)
     re_encoded = json.loads(serializer.toJSON(decoded))
     self.assertEqual(encoded, re_encoded)
Example #4
0
 def testRepeats(self):
   """Verifies serialization finds and removes repeated values."""
   test1 = ee.Image(5).mask(ee.Image(5))     # pylint: disable-msg=no-member
   expected1 = {
       'type': 'CompoundValue',
       'scope': [
           ['0', {
               'type': 'Invocation',
               'arguments': {
                   'value': 5
               },
               'functionName': 'Image.constant'
           }],
           ['1', {
               'type': 'Invocation',
               'arguments': {
                   'image': {
                       'type': 'ValueRef',
                       'value': '0'
                   },
                   'mask': {
                       'type': 'ValueRef',
                       'value': '0'
                   }
               },
               'functionName': 'Image.mask'
           }]
       ],
       'value': {
           'type': 'ValueRef',
           'value': '1'
       }
   }
   self.assertEquals(expected1, json.loads(serializer.toJSON(test1)))
 def testReuse(self):
   """Verifies that decoding results can be used and re-encoded."""
   input_image = ee.Image(13)
   output = deserializer.fromJSON(serializer.toJSON(input_image))
   self.assertEqual(
       output.addBands(42).serialize(),
       input_image.addBands(42).serialize())
Example #6
0
  def testSerialization(self):
    """Verifies a complex serialization case."""

    class ByteString(ee.Encodable):
      """A custom Encodable class that does not use invocations.

      This one is actually supported by the EE API encoding.
      """

      def __init__(self, value):
        """Creates a bytestring with a given string value."""
        self._value = value

      def encode(self, unused_encoder):  # pylint: disable-msg=g-bad-name
        return {
            'type': 'Bytes',
            'value': self._value
        }

    call = ee.ComputedObject('String.cat', {'string1': 'x', 'string2': 'y'})
    body = lambda x, y: ee.CustomFunction.variable(None, 'y')
    sig = {'returns': 'Object',
           'args': [
               {'name': 'x', 'type': 'Object'},
               {'name': 'y', 'type': 'Object'}]}
    custom_function = ee.CustomFunction(sig, body)
    to_encode = [
        None,
        True,
        5,
        7,
        3.4,
        2.5,
        'hello',
        ee.Date(1234567890000),
        ee.Geometry(ee.Geometry.LineString(1, 2, 3, 4), 'SR-ORG:6974'),
        ee.Geometry.Polygon([
            [[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]],
            [[5, 6], [7, 6], [7, 8], [5, 8]],
            [[1, 1], [2, 1], [2, 2], [1, 2]]
        ]),
        ByteString('aGVsbG8='),
        {
            'foo': 'bar',
            'baz': call
        },
        call,
        custom_function
    ]

    self.assertEquals(apitestcase.ENCODED_JSON_SAMPLE,
                      json.loads(serializer.toJSON(to_encode)))
Example #7
0
 def testCast(self):
     """Verifies that decoding casts the result to the right class."""
     input_image = ee.Image(13).addBands(42)
     output = deserializer.fromJSON(serializer.toJSON(input_image))
     self.assertTrue(isinstance(output, ee.Image))
Example #8
0
 def testRoundTrip(self):
     """Verifies a round trip of a comprehensive serialization case."""
     encoded = apitestcase.ENCODED_JSON_SAMPLE
     decoded = deserializer.decode(encoded)
     re_encoded = json.loads(serializer.toJSON(decoded))
     self.assertEquals(encoded, re_encoded)
 def testRepeats(self):
     """Verifies serialization finds and removes repeated values."""
     test1 = ee.Image(5).mask(ee.Image(5))  # pylint: disable-msg=no-member
     expected1 = {
         'type':
         'CompoundValue',
         'scope': [[
             '0', {
                 'type': 'Invocation',
                 'arguments': {
                     'value': 5
                 },
                 'functionName': 'Image.constant'
             }
         ],
                   [
                       '1', {
                           'type': 'Invocation',
                           'arguments': {
                               'image': {
                                   'type': 'ValueRef',
                                   'value': '0'
                               },
                               'mask': {
                                   'type': 'ValueRef',
                                   'value': '0'
                               }
                           },
                           'functionName': 'Image.mask'
                       }
                   ]],
         'value': {
             'type': 'ValueRef',
             'value': '1'
         }
     }
     self.assertEqual(
         expected1, json.loads(serializer.toJSON(test1,
                                                 for_cloud_api=False)))
     expected_cloud = {
         'values': {
             '0': {
                 'functionInvocationValue': {
                     'arguments': {
                         'image': {
                             'valueReference': '1'
                         },
                         'mask': {
                             'valueReference': '1'
                         }
                     },
                     'functionName': 'Image.mask'
                 }
             },
             '1': {
                 'functionInvocationValue': {
                     'arguments': {
                         'value': {
                             'constantValue': 5
                         }
                     },
                     'functionName': 'Image.constant'
                 }
             }
         },
         'result': '0'
     }
     expected_cloud_pretty = {
         'functionInvocationValue': {
             'arguments': {
                 'image': {
                     'functionInvocationValue': {
                         'arguments': {
                             'value': {
                                 'constantValue': 5
                             }
                         },
                         'functionName': 'Image.constant'
                     }
                 },
                 'mask': {
                     'functionInvocationValue': {
                         'arguments': {
                             'value': {
                                 'constantValue': 5
                             }
                         },
                         'functionName': 'Image.constant'
                     }
                 }
             },
             'functionName': 'Image.mask'
         }
     }
     self.assertEqual(expected_cloud,
                      serializer.encode(test1, for_cloud_api=True))
     self.assertEqual(
         expected_cloud_pretty,
         serializer.encode(test1, is_compound=False, for_cloud_api=True))
Example #10
0
    def testSerialization(self):
        """Verifies a complex serialization case."""
        class ByteString(ee.Encodable):
            """A custom Encodable class that does not use invocations.

      This one is actually supported by the EE API encoding.
      """
            def __init__(self, value):
                """Creates a bytestring with a given string value."""
                self._value = value

            def encode(self, unused_encoder):  # pylint: disable-msg=g-bad-name
                return {'type': 'Bytes', 'value': self._value}

            def encode_cloud_value(self, unused_encoder):
                # Proto3 JSON embedding of "bytes" values uses base64 encoding, which
                # this already is.
                return {'bytesValue': self._value}

        call = ee.ComputedObject('String.cat', {
            'string1': 'x',
            'string2': 'y'
        })
        body = lambda x, y: ee.CustomFunction.variable(None, 'y')
        sig = {
            'returns':
            'Object',
            'args': [{
                'name': 'x',
                'type': 'Object'
            }, {
                'name': 'y',
                'type': 'Object'
            }]
        }
        custom_function = ee.CustomFunction(sig, body)
        to_encode = [
            None, True, 5, 7, 3.4, 112233445566778899, 'hello',
            ee.Date(1234567890000),
            ee.Geometry(ee.Geometry.LineString(1, 2, 3, 4), 'SR-ORG:6974'),
            ee.Geometry.Polygon([[[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]],
                                 [[5, 6], [7, 6], [7, 8], [5, 8]],
                                 [[1, 1], [2, 1], [2, 2], [1, 2]]]),
            ByteString('aGVsbG8='), {
                'foo': 'bar',
                'baz': call
            }, call, custom_function
        ]

        self.assertEqual(
            apitestcase.ENCODED_JSON_SAMPLE,
            json.loads(serializer.toJSON(to_encode, for_cloud_api=False)))
        encoded = serializer.encode(to_encode, for_cloud_api=True)
        self.assertEqual(apitestcase.ENCODED_CLOUD_API_JSON_SAMPLE, encoded)
        pretty_encoded = serializer.encode(to_encode,
                                           is_compound=False,
                                           for_cloud_api=True)
        self.assertEqual(apitestcase.ENCODED_CLOUD_API_JSON_SAMPLE_PRETTY,
                         pretty_encoded)

        encoded_json = serializer.toJSON(to_encode, for_cloud_api=True)
        decoded_encoded_json = json.loads(encoded_json)
        self.assertEqual(encoded, decoded_encoded_json)
 def testCast(self):
   """Verifies that decoding casts the result to the right class."""
   input_image = ee.Image(13).addBands(42)
   output = deserializer.fromJSON(serializer.toJSON(input_image))
   self.assertTrue(isinstance(output, ee.Image))
 def testRoundTrip(self):
   """Verifies a round trip of a comprehensive serialization case."""
   encoded = apitestcase.ENCODED_JSON_SAMPLE
   decoded = deserializer.decode(encoded)
   re_encoded = json.loads(serializer.toJSON(decoded))
   self.assertEquals(encoded, re_encoded)