How to use descarteslabs - 10 common examples

def test_derived_bands_get(self):
        band_id = "derived:ndvi"
        try:
            d_band = self.instance.get_derived_band(band_id)
            assert "bands" in d_band
        except NotFoundError:
            pass

    @typecheck_promote(sep=lambda: (Str, NoneType), maxsplit=Int)
    def split(self, sep=None, maxsplit=-1):
        """
        Return a ``List[Str]`` of the words in the string, using sep as the delimiter string.

          sep
            The delimiter according which to split the string.
            None (the default value) means split according to any whitespace,
            and discard empty strings from the result.
          maxsplit
            Maximum number of splits to do.
            -1 (the default value) means no limit.
        """
        from ..containers import List

        return List[Str]._from_apply("Str.split", self, sep=sep, maxsplit=maxsplit)

@typecheck_promote(
    (Int, Float, Image, ImageCollection), (Int, Float, Image, ImageCollection)
)
def arctan2(y, x):
    """
    Element-wise arc tangent of ``y/x`` choosing the quadrant correctly.

    The quadrant (i.e., branch) is chosen so that ``arctan2(y, x)`` is
    the signed angle in radians between the ray ending at the origin and
    passing through the point (1,0), and the ray ending at the origin and
    passing through the point (x, y).  (Note the role reversal: the
    "y-coordinate" is the first function parameter, the "x-coordinate"
    is the second.)  By IEEE convention, this function is defined for
    x = +/-0 and for either or both of y and x = +/-inf (see
    Notes for specific values).

    Parameters

    @typecheck_promote((lambda: Image, lambda: _DelayedImageCollection(), Int, Float))
    def __lt__(self, other):
        return _result_type(other)._from_apply("lt", self, other)

    @typecheck_promote((lambda: Image, lambda: _DelayedImageCollection(), Int, Float))
    def __rpow__(self, other):
        return _result_type(other)._from_apply("pow", other, self)

    @typecheck_promote(lambda: Datetime)
    def __ne__(self, other):
        return Bool._from_apply("ne", self, other)

    @typecheck_promote(lambda: (Int, Float))
    def __sub__(self, other):
        return _binop_result(self, other)._from_apply("sub", self, other)

    @typecheck_promote(chars=lambda: (Str, NoneType))
    def lstrip(self, chars=None):
        """
        Return a copy of the string with leading whitespace removed.

        If chars is given and not None, remove characters in chars instead.
        """
        return self._from_apply("Str.lstrip", self, chars)

    @typecheck_promote(lambda: (Int, Float))
    def __le__(self, other):
        return Bool._from_apply("le", self, other)

    @typecheck_promote(lambda: Str)
    def __eq__(self, other):
        return Bool._from_apply("eq", self, other)