Returns a weka K-Means Clusterer.

    Cluster data using the k-means algorithm. Can use either the Euclidean
    distance (default) or the Manhattan distance. If the Manhattan distance is
    used, then centroids are computed as the component-wise median rather than
    mean. For more information see: D. Arthur, S. Vassilvitskii: k-means++: the
    advantages of careful seeding. In: Proceedings of the eighteenth annual
    ACM-SIAM symposium on Discrete algorithms, 1027-1035, 2007.

    Args:
      nClusters: Number of clusters.
      init: Initialization method to use. 0 = random, 1 = k-means++, 2 = canopy,
        3 = farthest first.
      canopies: Use canopies to reduce the number of distance calculations.
      maxCandidates: Maximum number of candidate canopies to retain in memory at
        any one time when using canopy clustering. T2 distance plus, data
        characteristics, will determine how many candidate canopies are formed
        before periodic and final pruning are performed, which might result in
        exceess memory consumption. This setting avoids large numbers of
        candidate canopies consuming memory.
      periodicPruning: How often to prune low density canopies when using canopy
        clustering.
      minDensity: Minimum canopy density, when using canopy clustering, below
        which a canopy will be pruned during periodic pruning.
      t1: The T1 distance to use when using canopy clustering. A value < 0 is
        taken as a positive multiplier for T2.
      t2: The T2 distance to use when using canopy clustering. Values < 0 cause
        a heuristic based on attribute std. deviation to be used.
      distanceFunction: Distance function to use. Options are: Euclidean and
        Manhattan.
      maxIterations: Maximum number of iterations.
      preserveOrder: Preserve order of instances.
      fast: Enables faster distance calculations, using cut-off values. Disables
        the calculation/output of squared errors/distances.
      seed: The randomization seed.


Returns a weka Learning Vector Quantization (LVQ) Clusterer.

    A Clusterer that implements the Learning Vector Quantization algorithm. For
    more details, see: T. Kohonen, "Learning Vector Quantization", The Handbook
    of Brain Theory and Neural Networks, 2nd Edition, MIT Press, 2003, pp.
    631-634.

    Args:
      numClusters: The number of clusters.
      learningRate: The learning rate for the training algorithm. Value should
        be greater than 0 and less or equal to 1.
      epochs: Number of training epochs. Value should be greater than or equal
        to 1.
      normalizeInput: Skip normalizing the attributes.


Returns a weka X-Means Clusterer.

    X-Means is K-Means with an efficient estimation of the number of clusters.
    For more information see: Dan Pelleg, Andrew W. Moore: X-means: Extending
    K-means with Efficient Estimation of the Number of Clusters. In: Seventeenth
    International Conference on Machine Learning, 727-734, 2000.

    Args:
      minClusters: Minimum number of clusters.
      maxClusters: Maximum number of clusters.
      maxIterations: Maximum number of overall iterations.
      maxKMeans: The maximum number of iterations to perform in KMeans.
      maxForChildren: The maximum number of iterations in KMeans that is
        performed on the child centers.
      useKD: Use a KDTree.
      cutoffFactor: Takes the given percentage of the split centroids if none of
        the children win.
      distanceFunction: Distance function to use. Options are: Chebyshev,
        Euclidean, and Manhattan.
      seed: The randomization seed.


Initializes the data module, setting credentials and base URLs.

  If any of the arguments are unspecified, they will keep their old values;
  the defaults if initialize() has never been called before.

  At least one of "credentials" and "cloud_api_key" must be provided. If both
  are provided, both will be used; in this case, the API key's project must
  match the credentials' project.

  Args:
    credentials: The OAuth2 credentials.
    api_base_url: The EarthEngine REST API endpoint.
    tile_base_url: The EarthEngine REST tile endpoint.
    cloud_api_base_url: The EarthEngine Cloud API endpoint.
    cloud_api_key: The API key to use with the Cloud API.
    project: The client project ID or number to use when making API calls.
    http_transport: The http transport to use


Resets the data module, clearing credentials and custom base URLs.


Returns the projects path to use for constructing a request.


Builds or rebuilds the Cloud API resource object, if needed.


Adds headers based on client context.


Handles profiling annotations on Cloud API responses.


Executes a Cloud API call and translates errors to EEExceptions.

  Args:
    call: The Cloud API call, with all parameters set, ready to have execute()
      called on it.
    num_retries: How many times retryable failures should be retried.

  Returns:
    The value returned by executing that call.

  Raises:
    EEException if the call fails.


Translates a Cloud API exception into an EEException.

  Args:
    http_error: A googleapiclient.errors.HttpError.

  Returns:
    An EEException bearing the error message from http_error.


Populates the workload tag on the request body passed in if applicable.

  Defaults to the workload tag set by ee.data.setWorkloadTag() or related
  methods. A workload tag already set on the body takes precedence. The workload
  tag will not be set if it's an empty string.

  Args:
    body: The request body.


Returns a context manager which enables or disables profiling.

  If hook is not None, enables profiling for all API calls in its scope and
  calls the hook function with all resulting profile IDs. If hook is null,
  disables profiling (or leaves it disabled).

  Args:
    hook: A function of one argument which is called with each profile
        ID obtained from API calls, just before the API call returns.


Returns the images in an image collection or folder.

  Args:
    params: Either a string representing the ID of the image collection to list,
      or an object containing request parameters with the following possible
      values, all but 'parent` are optional:
      parent - (string) The ID of the image collection to list, required.
      pageSize - (string) The number of results to return. If not specified, all
        results are returned.
      pageToken - (string) The token page of results to return.
      startTime - (ISO 8601 string): The minimum start time (inclusive).
      endTime - (ISO 8601 string): The maximum end time (exclusive).
      region - (GeoJSON or WKT string): A region to filter on.
      properties - (list of strings): A list of property filters to apply, for
        example, ["classification=urban", "size>=2"].
      filter - (string) An additional filter query to apply. Example query:
          `properties.my_property>=1 AND properties.my_property<2 AND
          startTime >= "2019-01-01T00:00:00.000Z" AND
          endTime < "2020-01-01T00:00:00.000Z" AND
          intersects("{'type':'Point','coordinates':[0,0]}")`
        See https://google.aip.dev/160 for how to construct a query.
      view - (string) Specifies how much detail is returned in the list. Either
        "FULL" (default) for all image properties or "BASIC".


Returns the assets in a folder.

  Args:
    params: Either a string representing the ID of the collection or folder to
      list, or an object containing request parameters with the following
      possible values, all but 'parent` are optional:
      parent - (string) The ID of the collection or folder to list, required.
      pageSize - (string) The number of results to return. If not specified, all
        results are returned.
      pageToken - (string) The token page of results to return.
      filter - (string) An additional filter query to apply. Example query:
        '''properties.my_property>=1 AND properties.my_property<2 AND
           startTime >= "2019-01-01T00:00:00.000Z" AND
           endTime < "2020-01-01T00:00:00.000Z" AND
           intersects("{'type':'Point','coordinates':[0,0]}")'''
        See https://google.aip.dev/160 for how to construct a query.
      view - (string) Specifies how much detail is returned in the list. Either
        "FULL" (default) for all image properties or "BASIC".


Returns top-level assets and folders for the Cloud Project or user.

  Args:
    project: Project to query, e.g., "projects/my-project". Defaults to current
      project. Use "projects/earthengine-legacy" for user home folders.

  Returns:
    A dictionary with a list of top-level assets and folders like:
      {"assets": [
          {"type": "FOLDER", "id": "projects/my-project/assets/my-folder", ...},
          {"type": "IMAGE", "id": "projects/my-project/assets/my-image", ...},
      ]}


Returns a generator for list methods that contain a next page token.


List features for a given table or FeatureView asset.

  Args:
    params: An object containing parameters with the following possible values:
      assetId - The asset ID for which to list features.
      pageSize - An optional max number of results per page, default is 1000.
      pageToken - An optional token identifying a new page of results the server
                  should return, usually taken from the response object.
      region - If present, a geometry defining a query region, specified as a
               GeoJSON geometry string (see RFC 7946).
      filter - If present, specifies additional simple property filters
               (see https://google.aip.dev/160).
      fileFormat - If present, specifies an output format for the tabular data.
          The function makes a network request for each page until the entire
          table has been fetched. The number of fetches depends on the number of
          rows in the table and pageSize. pageToken is ignored. Supported
          formats are: PANDAS_DATAFRAME for a Pandas DataFrame and
          GEOPANDAS_GEODATAFRAME for a GeoPandas GeoDataFrame.

  Returns:
    A Pandas DataFrame, GeoPandas GeoDataFrame, or a dictionary containing:
    - "type": always "FeatureCollection" marking this object as a GeoJSON
              feature collection.
    - "features": a list of GeoJSON features.
    - "next_page_token": A token to retrieve the next page of results in a
                         subsequent call to this function.


Computes a tile by performing an arbitrary computation on image data.

  Args:
    params: An object containing parameters with the following possible values:
      expression - The expression to compute.
      fileFormat - The resulting file format. Defaults to png. See
          https://developers.google.com/earth-engine/reference/rest/v1/ImageFileFormat
          for the available formats. There are additional formats that convert
          the downloaded object to a Python data object. These include:
          NUMPY_NDARRAY, which converts to a structured NumPy array.
      grid - Parameters describing the pixel grid in which to fetch data.
          Defaults to the native pixel grid of the data.
      bandIds - If present, specifies a specific set of bands from which to get
          pixels.
      visualizationOptions - If present, a set of visualization options to apply
          before the pixels are computed and returned. See
          https://developers.google.com/earth-engine/reference/rest/v1/VisualizationOptions
          for details.

  Returns:
    The pixels as raw image data.


Computes a list of images by applying a computation to features.

  Args:
    params: An object containing parameters with the following possible values:
      expression - The expression to compute.
      pageSize - The maximum number of results per page. The server may return
          fewer images than requested. If unspecified, the page size default is
          1000 results per page.
      pageToken - A token identifying a page of results the server should
                  return.
      workloadTag - User supplied tag to track this computation.

  Returns:
    A list with the results of the computation.


Computes a list of features by applying a computation to features.

  Args:
    params: An object containing parameters with the following possible values:
      expression - The expression to compute.
      pageSize - The maximum number of results per page. The server may return
          fewer images than requested. If unspecified, the page size default is
          1000 results per page.
      pageToken - A token identifying a page of results the server should
                  return.
      fileFormat - If present, specifies an output format for the tabular data.
          The function makes a network request for each page until the entire
          table has been fetched. The number of fetches depends on the number of
          rows in the table and pageSize. pageToken is ignored. Supported
          formats are: PANDAS_DATAFRAME for a Pandas DataFrame and
          GEOPANDAS_GEODATAFRAME for a GeoPandas GeoDataFrame.
      workloadTag - User supplied tag to track this computation.

  Returns:
    A Pandas DataFrame, GeoPandas GeoDataFrame, or a dictionary containing:
    - "type": always "FeatureCollection" marking this object as a GeoJSON
          feature collection.
    - "features": a list of GeoJSON features reprojected to EPSG:4326 with
          planar edges.
    - "next_page_token": A token to retrieve the next page of results in a
          subsequent call to this function.


Gets the URL format for this tile fetcher.

    Returns:
      A format string with {x}, {y}, and {z} placeholders.
      If you are using the Cloud API, and have not provided an API
      key, then this URL will require authorization. Use the credentials
      provided to ee.Initialize() to provide this authorization. Alternatively,
      use "fetch_tile" to fetch the tile data, which will handle the
      authorization for you.


Generates the URL for a particular tile.

    Args:
      x: The tile x coordinate.
      y: The tile y coordinate.
      z: The tile zoom level.

    Returns:
      The tile's URL.


Fetches the map tile specified by (x, y, z).

    This method uses any credentials that were specified to ee.Initialize().

    Args:
      x: The tile x coordinate.
      y: The tile y coordinate.
      z: The tile zoom level.

    Returns:
      The map tile image data bytes.

    Raises:
      EEException if the fetch fails.


Sends a request to compute a value.

  Args:
    obj: A ComputedObject whose value is desired.

  Returns:
    The result of evaluating that object on the server.


Create a thumbnail URL from the given thumbid.

  Args:
    thumbId: A dictionary containing a thumbnail thumbid.

  Returns:
    A URL from which the thumbnail can be obtained.


Create a download URL from the given docid.

  Args:
    downloadId: A dictionary containing a download docid.

  Returns:
    A URL from which the download can be obtained.


Create a table download URL from a docid.

  Args:
    downloadId: A dictionary with a table download docid.

  Returns:
    A Url from which the download can be obtained.


Creates an asset from a JSON value.

  To create an empty image collection or folder, pass in a "value" object
  with a "type" key whose value is "ImageCollection" or "Folder".
  If you are using the Cloud API, use "IMAGE_COLLECTION" or "FOLDER".

  Args:
    value: An object describing the asset to create.
    path: An optional desired ID, including full path.
    properties: The keys and values of the properties to set on the created
      asset.

  Returns:
    A description of the saved asset, including a generated ID.


Creates an asset folder.

  Returns a description of the newly created folder.

  Args:
    path: The path to the folder to create.

  Returns:
    A description of the newly created folder.


Copies the asset from sourceId into destinationId.

  Args:
    sourceId: The ID of the asset to copy.
    destinationId: The ID of the new asset created by copying.
    allowOverwrite: If True, allows overwriting an existing asset.


Renames the asset from sourceId to destinationId.

  Args:
    sourceId: The ID of the asset to rename.
    destinationId: The new ID of the asset.


Deletes the asset with the given id.

  Args:
    assetId: The ID of the asset to delete.


Generate an ID for a long-running task.

  Args:
    count: Optional count of IDs to generate, one by default.

  Returns:
    A list containing generated ID strings.


Retrieves a list of the user's tasks.

  Args:
    project: The project to list operations for, uses the default set project
      if none is provided.
  Returns:
    A list of Operation status dictionaries, one for each task submitted to EE
    by the current user. These include currently running tasks as well as
    recently canceled or failed tasks.


Starts an image export task running.

  This is a low-level method. The higher-level ee.batch.Export.image object
  is generally preferred for initiating image exports.

  Args:
    request_id (string): A unique ID for the task, from newTaskId.
      If you are using the cloud API, this does not need to be from newTaskId,
      (though that's a good idea, as it's a good source of unique strings).
      It can also be empty, but in that case the request is more likely to
      fail as it cannot be safely retried.
    params: The object that describes the export task.
      If you are using the cloud API, this should be an ExportImageRequest.
      However, the "expression" parameter can be the actual Image to be
      exported, not its serialized form.

  Returns:
    A dict with information about the created task.
    If you are using the cloud API, this will be an Operation.


Starts a table export task running.

  This is a low-level method. The higher-level ee.batch.Export.table object
  is generally preferred for initiating table exports.

  Args:
    request_id (string): A unique ID for the task, from newTaskId. If you are
      using the cloud API, this does not need to be from newTaskId, (though
      that's a good idea, as it's a good source of unique strings). It can also
      be empty, but in that case the request is more likely to fail as it cannot
      be safely retried.
    params: The object that describes the export task. If you are using the
      cloud API, this should be an ExportTableRequest. However, the "expression"
      parameter can be the actual FeatureCollection to be exported, not its
      serialized form.

  Returns:
    A dict with information about the created task.
    If you are using the cloud API, this will be an Operation.


Starts a video export task running.

  This is a low-level method. The higher-level ee.batch.Export.video object
  is generally preferred for initiating video exports.

  Args:
    request_id (string): A unique ID for the task, from newTaskId.
      If you are using the cloud API, this does not need to be from newTaskId,
      (though that's a good idea, as it's a good source of unique strings).
      It can also be empty, but in that case the request is more likely to
      fail as it cannot be safely retried.
    params: The object that describes the export task.
      If you are using the cloud API, this should be an ExportVideoRequest.
      However, the "expression" parameter can be the actual ImageCollection
      to be exported, not its serialized form.

  Returns:
    A dict with information about the created task.
    If you are using the cloud API, this will be an Operation.


Starts a map export task running.

  This is a low-level method. The higher-level ee.batch.Export.map object
  is generally preferred for initiating map tile exports.

  Args:
    request_id (string): A unique ID for the task, from newTaskId.
      If you are using the cloud API, this does not need to be from newTaskId,
      (though that's a good idea, as it's a good source of unique strings).
      It can also be empty, but in that case the request is more likely to
      fail as it cannot be safely retried.
    params: The object that describes the export task.
      If you are using the cloud API, this should be an ExportMapRequest.
      However, the "expression" parameter can be the actual Image to be
      exported, not its serialized form.

  Returns:
    A dict with information about the created task.
    If you are using the cloud API, this will be an Operation.


Starts a classifier export task.

  This is a low-level method. The higher-level ee.batch.Export.classifier
  object is generally preferred for initiating classifier exports.

  Args:
    request_id (string): A unique ID for the task, from newTaskId. If you are
      using the cloud API, this does not need to be from newTaskId, (though
      that's a good idea, as it's a good source of unique strings). It can also
      be empty, but in that case the request is more likely to fail as it cannot
      be safely retried.
    params: The object that describes the export task. If you are using the
      cloud API, this should be an ExportClassifierRequest. However, the
      "expression" parameter can be the actual Classifier to be exported, not
      its serialized form.

  Returns:
    A dict with information about the created task.
    If you are using the cloud API, this will be an Operation.


Starts an export task running.

  Args:
    request_id (string): An optional unique ID for the task.
    params: The object that describes the export task. The "expression"
      parameter can be the actual object to be exported, not its serialized
      form. This may be modified.
    export_endpoint: A callable representing the export endpoint to invoke
      (e.g., _get_cloud_api_resource().image().export).

  Returns:
    An Operation with information about the created task.


Starts an ingestion task or creates an external image.


Creates an image asset import task.

  Args:
    request_id (string): A unique ID for the ingestion, from newTaskId.
      If you are using the Cloud API, this does not need to be from newTaskId,
      (though that's a good idea, as it's a good source of unique strings).
      It can also be empty, but in that case the request is more likely to
      fail as it cannot be safely retried.
    params: The object that describes the import task, which can
        have these fields:
          name (string) The destination asset id (e.g.,
             "projects/myproject/assets/foo/bar").
          tilesets (array) A list of Google Cloud Storage source file paths
            formatted like:
              [{'sources': [
                  {'uris': ['foo.tif', 'foo.prj']},
                  {'uris': ['bar.tif', 'bar.prj']},
              ]}]
            Where path values correspond to source files' Google Cloud Storage
            object names, e.g., 'gs://bucketname/filename.tif'
          bands (array) An optional list of band names formatted like:
            [{'id': 'R'}, {'id': 'G'}, {'id': 'B'}]
        In general, this is a dict representation of an ImageManifest.
    allow_overwrite: Whether the ingested image can overwrite an
        existing version.

  Returns:
    A dict with notes about the created task. This will include the ID for the
    import task (under 'id'), which may be different from request_id.


Creates an external image.

  Args:
    image_manifest: The object that describes the import task, which can
        have these fields:
          name (string) The destination asset id (e.g.,
             "projects/myproject/assets/foo/bar").
          tilesets (array) A list of Google Cloud Storage source file paths
            formatted like:
              [{'sources': [
                  {'uris': ['foo.tif', 'foo.prj']},
                  {'uris': ['bar.tif', 'bar.prj']},
              ]}]
            Where path values correspond to source files' Google Cloud Storage
            object names, e.g., 'gs://bucketname/filename.tif'
          bands (array) An optional list of band names formatted like:
            [{'id': 'R'}, {'id': 'G'}, {'id': 'B'}]
        In general, this is a dict representation of an ImageManifest.
    allow_overwrite: Whether the ingested image can overwrite an
        existing version.

  Returns:
    The name of the created asset.


Creates a table asset import task.

  Args:
    request_id (string): A unique ID for the ingestion, from newTaskId.
      If you are using the Cloud API, this does not need to be from newTaskId,
      (though that's a good idea, as it's a good source of unique strings).
      It can also be empty, but in that case the request is more likely to
      fail as it cannot be safely retried.
    params: The object that describes the import task, which can
        have these fields:
          name (string) The destination asset id (e.g.,
             "projects/myproject/assets/foo/bar").
          sources (array) A list of GCS (Google Cloud Storage) file paths
            with optional character encoding formatted like this:
            "sources":[{"uris":["gs://bucket/file.shp"],"charset":"UTF-8"}]
            Here 'charset' refers to the character encoding of the source file.
        In general, this is a dict representation of a TableManifest.
    allow_overwrite: Whether the ingested image can overwrite an
        existing version.
  Returns:
    A dict with notes about the created task. This will include the ID for the
    import task (under 'id'), which may be different from request_id.


Updates an asset.

  Args:
    asset_id: The ID of the asset to update.
    asset: The updated version of the asset, containing only the new values of
      the fields to be updated. Only the "start_time", "end_time", and
      "properties" fields can be updated. If a value is named in "update_mask",
      but is unset in "asset", then that value will be deleted from the asset.
    update_mask: A list of the values to update. This should contain the strings
      "start_time" or "end_time" to update the corresponding timestamp. If
      a property is to be updated or deleted, it should be named here as
      "properties.THAT_PROPERTY_NAME". If the entire property set is to be
      replaced, this should contain the string "properties". If this list is
      empty, all properties and both timestamps will be updated.


Attempts to create a home root folder for the current user ("users/joe").

  Results in an error if the user already has a home root folder or the
  requested ID is unavailable.

  Args:
    requestedId: The requested ID of the home folder (e.g., "users/joe").


Updates the project config for the current project.

  Args:
    project_config: The new project config as a dictionary.
    update_mask: A list of the values to update. The only supported values right
      now are: "max_concurrent_exports". If the list is empty or None, all
      values will be updated.

  Returns:
    The updated project config as a dictionary.


Creates the specified assets if they do not exist.


Produces a context manager which sets the workload tag, then resets it.

  Workload tag must be 1 - 63 characters, beginning and ending with an
  alphanumeric character ([a-z0-9A-Z]) with dashes (-), underscores (_), dots
  (.), and alphanumerics between, or an empty string to clear the workload tag.

  Args:
    tag: The tag to set.

  Yields:
    None.


Sets the default tag for which to reset back to.

  If resetDefault parameter is set to true, the default will be set to empty
  before resetting. Defaults to False.

  Args:
    resetDefault: Whether to reset the default back to empty.


Throws an error if setting an invalid tag.

    Args:
      tag: the tag to validate.

    Returns:
      The validated tag.

    Raises:
      ValueError if the tag does not match the expected format.


Removes imported API functions from this class.

    Also resets the serial ID used for mapping Python functions to 0.


Returns a list of all the values of the selected property.

    Aggregates over a given property of the objects in a collection, calculating
    a list of all the values of the selected property.

    Args:
      property: The property to use from each element of the collection.


Returns the number of distinct values of the selected property.

    Aggregates over a given property of the objects in a collection, calculating
    the number of distinct values for the selected property.

    Args:
      property: The property to use from each element of the collection.


Returns the first value of the selected property.

    Aggregates over a given property of the objects in a collection, calculating
    the property value of the first object in the collection.

    Args:
      property: The property to use from each element of the collection.


Returns a histogram of the selected property as a dictionary.

    Aggregates over a given property of the objects in a collection, calculating
    a histogram of the selected property.

    Args:
      property: The property to use from each element of the collection.

    Returns:
      An ee.Dictionary.


Returns the maximum value of the selected property.

    Aggregates over a given property of the objects in a collection, calculating
    the maximum of the values of the selected property.

    Args:
      property: The property to use from each element of the collection.


Returns the mean of the selected property.

    Aggregates over a given property of the objects in a collection, calculating
    the mean of the selected property.

    Args:
      property: The property to use from each element of the collection.


Returns the minimum value of the selected property.

    Aggregates over a given property of the objects in a collection, calculating
    the minimum of the values of the selected property.

    Args:
      property: The property to use from each element of the collection.


Returns the product of the values ofthe selected property.

    Aggregates over a given property of the objects in a collection, calculating
    the product of the values of the selected property.

    Args:
      property: The property to use from each element of the collection.


Returns the sample standard deviation of the selected property.

    Aggregates over a given property of the objects in a collection, calculating
    the sample std. deviation of the values of the selected property.

    Args:
      property: The property to use from each element of the collection.


Returns the sample variance of the selected property.

    Aggregates over a given property of the objects in a collection, calculating
    the sample variance of the values of the selected property.

    Args:
      property: The property to use from each element of the collection.

    Returns:
      An ee.Number.


Returns a dictionary of statistics for the selected property.

    Aggregates over a given property of the objects in a collection, calculating
    the sum, min, max, mean, sample standard deviation, sample variance, total
    standard deviation and total variance of the selected property.

    Args:
      property: The property to use from each element of the collection.


Returns the sum of the values of the selected property.

    Aggregates over a given property of the objects in a collection, calculating
    the sum of the values of the selected property.

    Args:
      property: The property to use from each element of the collection.


Returns the total standard deviation of the selected property.

    Aggregates over a given property of the objects in a collection, calculating
    the total std. deviation of the values of the selected property.

    Args:
      property: The property to use from each element of the collection.


Returns the total variance of the selected property.

    Aggregates over a given property of the objects in a collection, calculating
    the total variance of the values of the selected property.

    Args:
      property: The property to use from each element of the collection.


Returns the bounding rectangle of the geometry.

    Args:
      maxError: The maximum amount of error tolerated when performing any
        necessary reprojection.
      proj: If specified, the result will be in this projection. Otherwise it
        will be in EPSG:4326.


Returns a distance image for the collection.

    Produces a DOUBLE image where each pixel is the distance in meters from the
    pixel center to the nearest Point, LineString, or polygonal boundary in the
    collection. Note distance is also measured within interiors of polygons.
    Pixels that are not within 'searchRadius' meters of a geometry will be
    masked out.

    Distances are computed on a sphere, so there is a small error proportional
    to the latitude difference between each pixel and the nearest geometry.

    Args:
      searchRadius: Maximum distance in meters from each pixel to look for
        edges. Pixels will be masked unless there are edges within this
        distance.
      maxError: Maximum reprojection error in meters, only used if the input
        polylines require reprojection. If '0' is provided, then this operation
        will fail if projection is required.


Returns a collection with duplicates removed.

    Removes duplicates from a collection. Note that duplicates are determined
    using a strong hash over the serialized form of the selected properties.

    Args:
      properties: A property name or a list of property names to use for
        comparison. The '.geo' property can be included to compare object
        geometries.


Returns a painted image of a vector collection for visualization.

    Not intended for use as input to other algorithms.

    Args:
      color: A hex string in the format RRGGBB specifying the color to use for
        drawing the features.
      pointRadius: The radius in pixels of the point markers.
      strokeWidth: The width in pixels of lines and polygon borders.


Returns a 2D error matrix for a collection.

    Computes a 2D error matrix for a collection by comparing two columns of a
    collection: one containing the actual values, and one containing predicted
    values. The values are expected to be small contiguous integers, starting
    from 0.

    Axis 0 (the rows) of the matrix correspond to the actual values, and Axis 1
    (the columns) to the predicted values.

    Args:
      actual: The name of the property containing the actual value.
      predicted: The name of the property containing the predicted value.
      order: A list of the expected values. If this argument is not specified,
        the values are assumed to be contiguous and span the range 0 to
        maxValue. If specified, only values matching this list are used, and the
        matrix will have dimensions and order matching this list.


Apply a filter to this collection.

    Args:
      new_filter: Filter to add to this collection.

    Returns:
      The filtered collection object.


Shortcut to add a metadata filter to a collection.

    This is equivalent to self.filter(Filter().metadata(...)).

    Args:
      name: Name of a property to filter.
      operator: Name of a comparison operator as defined
          by FilterCollection.  Possible values are: "equals", "less_than",
          "greater_than", "not_equals", "not_less_than", "not_greater_than",
          "starts_with", "ends_with", "not_starts_with", "not_ends_with",
          "contains", "not_contains".
      value: The value to compare against.

    Returns:
      The filtered collection.


Shortcut to add a geometry filter to a collection.

    Items in the collection with a footprint that fails to intersect
    the given geometry will be excluded.
    This is equivalent to self.filter(Filter().geometry(...)).

    Caution: providing a large or complex collection as the `geometry` argument
    can result in poor performance. Collating the geometry of collections does
    not scale well; use the smallest collection (or geometry) that is required
    to achieve the desired outcome.

    Args:
      geometry: The boundary to filter to either as a GeoJSON geometry,
          or a FeatureCollection, from which a geometry will be extracted.

    Returns:
      The filtered collection.


Shortcut to filter a collection with a date range.

    Items in the collection with a system:time_start property that doesn't
    fall between the start and end dates will be excluded.
    This is equivalent to self.filter(ee.Filter.date(...)); see the ee.Filter
    type for other date filtering options.

    Args:
      start: The start date as a Date object, a string representation of a date,
        or milliseconds since epoch.
      end: The end date as a Date object, a string representation of a date, or
        milliseconds since epoch.

    Returns:
      The filter object.


Returns the geometry of a collection.

    Extracts and merges the geometries of a collection. Requires that all the
    geometries in the collection share the projection and edge
    interpretation.

    Caution: providing a large or complex collection as input can result in poor
    performance. Collating the geometry of collections does not scale well; use
    the smallest collection that is required to achieve the desired outcome.

    Args:
      maxError: An error margin to use when merging geometries.


Iterates over a collection with an algorithm.

    Applies a user-supplied function to each element of a collection. The
    user-supplied function is given two arguments: the current element, and
    the value returned by the previous call to iterate() or the first argument,
    for the first iteration. The result is the value returned by the final
    call to the user-supplied function.

    Args:
      algorithm: The function to apply to each element. Must take two
          arguments - an element of the collection and the value from the
          previous iteration.
      first: The initial state.

    Returns:
      The result of the Collection.iterate() call.

    Raises:
      ee_exception.EEException: if algorithm is not a function.


Limit a collection to the specified number of elements.

    This limits a collection to the specified number of elements, optionally
    sorting them by a specified prop first.

    Args:
       maximum: The number to limit the collection to.
       prop: The property to sort by, if sorting.
       ascending: Whether to sort in ascending or descending order. The default
         is true (ascending).

    Returns:
       The collection.


Returns a Collection of features from a specified table.

    Args:
      tableId: The asset ID of the table to load.
      geometryColumn: The name of the column to use as the main feature
        geometry. Not used if tableId is an asset ID.
      version: The version of the asset. -1 signifies the latest version.
        Ignored unless tableId is an asset ID.


Maps an algorithm over a collection.

    Args:
      algorithm: The operation to map over the images or features of the
        collection, a Python function that receives an image or features and
        returns one. The function is called only once and the result is captured
        as a description, so it cannot perform imperative operations or rely on
        external state.
      dropNulls: If true, the mapped algorithm is allowed to return nulls, and
        the elements for which it returns nulls will be dropped.

    Returns:
      The mapped collection.

    Raises:
      ee_exception.EEException: if algorithm is not a function.


Returns a collection with the elements from two collections.

    Merges two collections into one. The result has all the elements that were
    in either collection.

    Elements from the first collection will have IDs prefixed with "1_" and
    elements from the second collection will have IDs prefixed with "2_".

    Note: If many collections need to be merged, consider placing them all in a
    collection and using FeatureCollection.flatten() instead. Repeated use of
    FeatureCollection.merge() will result in increasingly long element IDs and
    reduced performance.

    Args:
      collection2: The second collection to merge.


Returns a collection with a random column added to each feature.

    Adds a column of deterministic pseudorandom numbers to a collection. The
    outputs are double-precision floating point numbers. When using the
    'uniform' distribution (default), outputs are in the range of [0, 1). Using
    the 'normal' distribution, outputs have mu=0, sigma=1, but have no explicit
    limits.

    Args:
      columnName: The name of the column to add.
      seed: A seed used when generating the random numbers.
      distribution: The distribution type of random numbers to produce; one of
        'uniform' or 'normal'.
      rowKeys: A list of properties that should uniquely and repeatably identify
        an element of the collection, used to generate the random number.
        Defaults to [system:index].


Returns a dictionary of results, keyed with the output names.

    Apply a reducer to each element of a collection, using the given selectors
    to determine the inputs.
    Returns a dictionary of results, keyed with the output names.

    Args:
      reducer: The reducer to apply.
      selectors: A selector for each input of the reducer.
      weightSelectors: A selector for each weighted input of the reducer.


Returns an image from a collection using a reducer.

    Creates an image from a feature collection by applying a reducer over the
    selected properties of all the features that intersect each pixel.

    Args:
      properties: Properties to select from each feature and pass into the
        reducer.
      reducer: A Reducer to combine the properties of each intersecting feature
        into a final result to store in the pixel.


Remaps the value of a specific property in a collection.

    Takes two parallel lists and maps values found in one to values in the
    other. Any element with a value that is not specified in the first list is
    dropped from the output collection.

    Args:
      lookupIn: The input mapping values. Restricted to strings and integers.
      lookupOut: The output mapping values. Must be the same size as lookupIn.
      columnName: The name of the property to remap.

    Returns:
      An ee.FeatureCollection.


Sort a collection by the specified property.

    Args:
       prop: The property to sort by.
       ascending: Whether to sort in ascending or descending order.  The default
         is true (ascending).

    Returns:
       The collection.


Draw a vector collection for visualization using a simple style language.

    Args:
      color: A default color (CSS 3.0 color value e.g., 'FF0000' or 'red') to
        use for drawing the features. Supports opacity (e.g., 'FF000088' for 50%
        transparent red).
      pointSize: The default size in pixels of the point markers.
      pointShape: The default shape of the marker to draw at each point
        location. One of: `circle`, `square`, `diamond`, `cross`, `plus`,
        `pentagram`, `hexagram`, `triangle`, `triangle_up`, `triangle_down`,
        `triangle_left`, `triangle_right`, `pentagon`, `hexagon`, `star5`,
        `star6`. This argument also supports these Matlab marker abbreviations:
        `o`, `s`, `d`, `x`, `+`, `p`, `h`, `^`, `v`, `<`, `>`.
      width: The default line width for lines and outlines for polygons and
        point shapes.
      fillColor: The color for filling polygons and point shapes. Defaults to
        'color' at 0.66 opacity.
      styleProperty: A per-feature property expected to contain a dictionary.
        Values in the dictionary override any default values for that feature.
      neighborhood: If styleProperty is used and any feature has a pointSize or
        width larger than the defaults, tiling artifacts can occur. Specifies
        the maximum neighborhood (pointSize + width) needed for any feature.
      lineType: The default line style for lines and outlines of polygons and
        point shapes. Defaults to 'solid'. One of: solid, dotted, dashed.

    Returns:
      An ee.Image.


Returns the elements of a collection as a list.

    Args:
      count: The maximum number of elements to fetch.
      offset: The number of elements to discard from the start. If set, (offset
        + count) elements will be fetched and the first offset elements will be
        discarded.


Returns a collection containing a single feature with a unioned geometry.

    Merges all geometries in a given collection into one and returns a
    collection containing a single feature with only an ID of 'union_result' and
    a geometry.

    Args:
      maxError: The maximum error allowed when performing any necessary
        reprojections. If not specified, defaults to the error margin requested
        from the output.


Returns the number of dimensions for this type.

    Returns:
      An ee.Number. 0 for scalar values and >= 1 for array values.


Returns the precision of the PixelType.

    Returns:
      An ee.String. One of 'int', 'float', or 'double'.


Returns a Maximum Entropy classifier.

    Maxent is used to model species distribution probabilities using
    environmental data for locations of known presence and for a large number of
    'background' locations. For more information and to cite, see:
    https://biodiversityinformatics.amnh.org/open_source/maxent/ and the
    reference publication: Phillips, et al., 2004. A maximum entropy approach
    to species distribution modeling, Proceedings of the Twenty-First
    International Conference on Machine Learning. The output is a single band
    named 'probability', containing the modeled probability,  and an additional
    band named 'clamp' when the 'writeClampGrid' argument is true.

    Args:
      categoricalNames: A list of the names of the categorical inputs. Any
        inputs not listed in this argument are considered to be continuous.
      outputFormat: Representation of probabilities in output.
      autoFeature: Automatically select which feature classes to use, based on
        number of training samples.
      linear: Allow linear features to be used. Ignored when autofeature is
        true.
      quadratic: Allow quadratic features to be used. Ignored when autofeature
        is true.
      product: Allow product features to be used. Ignored when autofeature is
        true.
      threshold: Allow threshold features to be used. Ignored when autofeature
        is true.
      hinge: Allow hinge features to be used. Ignored when autofeature is true.
      hingeThreshold: Number of samples at which hinge features start being
        used. Ignored when autofeature is false.
      l2lqThreshold: Number of samples at which quadratic features start being
        used. Ignored when autofeature is false.
      lq2lqptThreshold: Number of samples at which product and threshold
        features start being used. Ignored when autofeature is false.
      addSamplesToBackground: Add to the background any sample for which has a
        combination of environmental values that isn't already present in the
        background.
      addAllSamplesToBackground: Add all samples to the background, even if they
        have combinations of environmental values that are already present in
        the background.
      betaMultiplier: Regularization multiplier. Multiply all automatic
        regularization parameters by this number. A higher number gives a more
        spread-out distribution.
      betaHinge: Regularization parameter to be applied to all hinge features;
        negative value enables automatic setting.
      betaLqp: Regularization parameter to be applied to all linear, quadratic
        and product features; negative value enables automatic setting.
      betaCategorical: Regularization parameter to be applied to all categorical
        features; negative value enables automatic setting.
      betaThreshold: Regularization parameter to be applied to all threshold
        features; negative value enables automatic setting.
      extrapolate: Extrapolate. Predict to regions of environmental space
        outside the limits encountered during training.
      doClamp: Apply clamping to output.
      writeClampGrid: Adds a band to the output ('clamp') showing the spatial
        distribution of clamping. At each point, the value is the absolute
        difference between prediction values with and without clamping.
      randomTestPoints: Random test percentage. The percentage of training
        points to hold aside as test points, used to compute AUX, omission, etc.
      seed: A seed used when generating random numbers.


Returns a 2D confusion matrix.

    Computes a 2D confusion matrix for a classifier based on its training data
    (e.g., resubstitution error). Axis 0 of the matrix corresponds to the input
    classes and axis 1 corresponds to the output classes. The rows and columns
    start at class 0 and increase sequentially up to the maximum class value, so
    some rows or columns might be empty if the input classes aren't 0-based or
    sequential.


Returns a classifier that applies the given decision tree.

    Args:
      treeString: The decision tree, specified in the text format generated by R
        and other similar tools.


Creates a classifier that applies the given decision trees.

    Args:
      treeStrings: The decision trees, specified in the text format generated by
        R and other similar tools. Each item in the list should contain one or
        more trees in text format.

    Returns:
      An ee.Classifier.


Returns a classifier from an asset.

    Args:
      id: The Classifier's Asset ID.

    Returns:
      An ee.Classifier.


Returns a minimum distance classifier for the given distance metric.

    Creates a minimum distance classifier for the given distance metric. In
    CLASSIFICATION mode, the nearest class is returned. In REGRESSION mode, the
    distance to the nearest class center is returned. In RAW mode, the distance
    to every class center is returned.

    Args:
      metric: The distance metric to use. Options are:
        * 'euclidean' - Euclidean distance from the unnormalized class mean.
        * 'cosine' - spectral angle from the unnormalized class mean.
        * 'mahalanobis' - Mahalanobis distance from the class mean.
        * 'manhattan' - Manhattan distance from the unnormalized class mean.
      kNearest: If greater than 1, the result will contain an array of the k
        nearest neighbors or distances, based on the output mode setting. If
        kNearest is greater than the total number of classes, it will be set
        equal to the number of classes.


Returns the classifier mode string.

    The string will be one of `CLASSIFICATION`, `REGRESSION`, `PROBABILITY`,
    `MULTIPROBABILITY`, `RAW`, or `RAW_REGRESSION`.


Returns a list of the schema of the classifier.

    Returns the names of the inputs used by this classifier or null if this
    classifier has not had any training data added yet.


Returns an empty CART classifier.

    See: Classification and Regression Trees, L. Breiman, J. Friedman, R.
    Olshen, C. Stone Chapman and Hall, 1984.

    Args:
      maxNodes: The maximum number of leaf nodes in each tree. If unspecified,
        defaults to no limit.
      minLeafPopulation: Only create nodes whose training set contains at least
        this many points.


Returns an empty Gradient Tree Boost classifier.

    Args:
      numberOfTrees: The number of decision trees to create.
      shrinkage: The shrinkage parameter in (0, 1] controls the learning rate of
        procedure.
      samplingRate: The sampling rate for stochastic tree boosting.
      maxNodes: The maximum number of leaf nodes in each tree. If unspecified,
        defaults to no limit.
      loss: Loss function for regression. One of: LeastSquares,
        LeastAbsoluteDeviation, Huber.
      seed: The randomization seed.


Returns an empty k-NN classifier.

    The k-nearest neighbor algorithm (k-NN) is a method for classifying objects
    by a majority vote of its neighbors, with the object being assigned to the
    class most common amongst its k nearest neighbors (k is a positive integer,
    typically small, typically odd).

    Args:
      k: The number of neighbors for classification.
      searchMethod: Search method. The following are valid: [AUTO,
        LINEAR_SEARCH, KD_TREE, COVER_TREE]. AUTO will choose between KD_TREE
        and COVER_TREE depending on the dimension count. Results may vary
        between the different search methods for distance ties and probability
        values. Since performance and results may vary consult with SMILE's
        documentation and other literature.
      metric: The distance metric to use. NOTE: KD_TREE (and AUTO for low
        dimensions) will not use the metric selected. Options are:
        * 'EUCLIDEAN' - Euclidean distance.
        * 'MAHALANOBIS' - Mahalanobis distance.
        * 'MANHATTAN' - Manhattan distance.
        * 'BRAYCURTIS' - Bray-Curtis distance.


Returns an empty Naive Bayes classifier.

    This classifier assumes that the feature vector consists of positive
    integers, and negative inputs are discarded.

    Args:
      lambda: A smoothing lambda. Used to avoid assigning zero probability to
        classes not seen during training, instead using lambda / (lambda *
        nFeatures).


Returns an empty Random Forest classifier.

    Args:
      numberOfTrees: The number of decision trees to create.
      variablesPerSplit: The number of variables per split. If unspecified, uses
        the square root of the number of variables.
      minLeafPopulation: Only create nodes whose training set contains at least
        this many points.
      bagFraction: The fraction of input to bag per tree.
      maxNodes: The maximum number of leaf nodes in each tree. If unspecified,
        defaults to no limit.
      seed: The randomization seed.


Returns a spectral region classifier.

    Creates a classifier that tests if its inputs lie within a polygon defined
    by a set  of coordinates in an arbitrary 2D coordinate system. Each input to
    be classified  must have 2 values (e.g., images must have 2 bands). The
    result will be 1 wherever  the input values are contained within the given
    polygon and 0 otherwise.

    Args:
      coordinates: The coordinates of the polygon, as a list of rings. Each ring
        is a list of coordinate pairs (e.g., [u1, v1, u2, v2, ..., uN, vN]). No
        edge may intersect any other edge. The resulting classification will be
        a 1 wherever the input values are within the interior of the given
        polygon, that is, an odd number of polygon edges must be crossed to get
        outside the polygon and 0 otherwise.
      schema: The classifier's schema. A list of band or property names that the
        classifier will operate on. Since this classifier doesn't undergo a
        training step, these have to be specified manually. Defaults to ['u',
        'v'].


Returns a trained classifier.

    Trains the classifier on a collection of features, using the specified
    numeric properties of each feature as training data. The geometry of the
    features is ignored.

    Args:
      features: The collection to train on.
      classProperty: The name of the property containing the class value. Each
        feature must have this property and its value must be numeric.
      inputProperties: The list of property names to include as training data.
        Each feature must have all these properties and their values must be
        numeric. This argument is optional if the input collection contains a
        'band_order' property, (as produced by Image.sample).
      subsampling: An optional subsampling factor, within (0, 1].
      subsamplingSeed: A randomization seed to use for subsampling.


Returns the addition of two kernels.

    Does pointwise addition after aligning their centers.

    Args:
      kernel2: The second kernel.
      normalize: Normalize the kernel.

    Returns:
      An ee.Kernel.


Returns a Chebyshev kernel.

    Generates a distance kernel based on Chebyshev distance (greatest distance
    along any dimension).

    Args:
      radius: The radius of the kernel to generate.
      units: The system of measurement for the kernel ('pixels' or 'meters'). If
        the kernel is specified in meters, it will resize when the zoom-level is
        changed.
      normalize: Normalize the kernel values to sum to 1.
      magnitude: Scale each value by this amount.


Returns a circle-shaped boolean kernel.

    Args:
      radius: The radius of the kernel to generate.
      units: The system of measurement for the kernel ('pixels' or 'meters'). If
        the kernel is specified in meters, it will resize when the zoom-level is
        changed.
      normalize: Normalize the kernel values to sum to 1.
      magnitude: Scale each value by this amount.


Returns a 3x3 Prewitt's Compass edge-detection kernel.

    Args:
      magnitude: Scale each value by this amount.
      normalize: Normalize the kernel values to sum to 1.


Returns a cross-shaped boolean kernel.

    Args:
      radius: The radius of the kernel to generate.
      units: The system of measurement for the kernel ('pixels' or 'meters'). If
        the kernel is specified in meters, it will resize when the zoom-level is
        changed.
      normalize: Normalize the kernel values to sum to 1.
      magnitude: Scale each value by this amount.


Returns a diamond-shaped boolean kernel.

    Args:
      radius: The radius of the kernel to generate.
      units: The system of measurement for the kernel ('pixels' or 'meters'). If
        the kernel is specified in meters, it will resize when the zoom-level is
        changed.
      normalize: Normalize the kernel values to sum to 1.
      magnitude: Scale each value by this amount.


Returns a distance kernel based on Euclidean (straight-line) distance.

    Args:
      radius: The radius of the kernel to generate.
      units: The system of measurement for the kernel ('pixels' or 'meters'). If
        the kernel is specified in meters, it will resize when the zoom-level is
        changed.
      normalize: Normalize the kernel values to sum to 1.
      magnitude: Scale each value by this amount.


Returns a kernel with the given weights.

    Args:
      width: The width of the kernel in pixels.
      height: The height of the kernel in pixels.
      weights: A 2-D list of [height] x [width] values to use as the weights of
        the kernel.
      x: The location of the focus, as an offset from the left.
      y: The location of the focus, as an offset from the top.
      normalize: Normalize the kernel values to sum to 1.


Returns a Gaussian kernel from a sampled continuous Gaussian.

    Args:
      radius: The radius of the kernel to generate.
      sigma: Standard deviation of the Gaussian function (same units as radius).
      units: The system of measurement for the kernel ('pixels' or 'meters'). If
        the kernel is specified in meters, it will resize when the zoom-level is
        changed.
      normalize: Normalize the kernel values to sum to 1.
      magnitude: Scale each value by this amount.


Returns a kernel which has each of its weights multiplicatively inverted.

    Weights with a value of zero are not inverted and remain zero.


Returns a 3x3 Kirsch's Compass edge-detection kernel.

    Args:
      magnitude: Scale each value by this amount.
      normalize: Normalize the kernel values to sum to 1.


Returns a 3x3 Laplacian-4 edge-detection kernel.

    Args:
      magnitude: Scale each value by this amount.
      normalize: Normalize the kernel values to sum to 1.


Returns a 3x3 Laplacian-8 edge-detection kernel.

    Args:
      magnitude: Scale each value by this amount.
      normalize: Normalize the kernel values to sum to 1.


Returns a distance kernel based on rectilinear (city-block) distance.

    Args:
      radius: The radius of the kernel to generate.
      units: The system of measurement for the kernel ('pixels' or 'meters'). If
        the kernel is specified in meters, it will resize when the zoom-level is
        changed.
      normalize: Normalize the kernel values to sum to 1.
      magnitude: Scale each value by this amount.


Returns an octagon-shaped boolean kernel.

    Args:
      radius: The radius of the kernel to generate.
      units: The system of measurement for the kernel ('pixels' or 'meters'). If
        the kernel is specified in meters, it will resize when the zoom-level is
        changed.
      normalize: Normalize the kernel values to sum to 1.
      magnitude: Scale each value by this amount.


Returns a plus-shaped boolean kernel.

    Args:
      radius: The radius of the kernel to generate.
      units: The system of measurement for the kernel ('pixels' or 'meters'). If
        the kernel is specified in meters, it will resize when the zoom-level is
        changed.
      normalize: Normalize the kernel values to sum to 1.
      magnitude: Scale each value by this amount.


Returns a 3x3 Prewitt edge-detection kernel.

    Args:
      magnitude: Scale each value by this amount.
      normalize: Normalize the kernel values to sum to 1.


Returns a rectangular-shaped kernel.

    Args:
      xRadius: The horizontal radius of the kernel to generate.
      yRadius: The vertical radius of the kernel to generate.
      units: The system of measurement for the kernel ("pixels" or "meters"). If
        the kernel is specified in meters, it will resize when the zoom-level is
        changed.
      normalize: Normalize the kernel values to sum to 1.
      magnitude: Scale each value by this amount.


Returns a 2x2 Roberts edge-detection kernel.

    Args:
      magnitude: Scale each value by this amount.
      normalize: Normalize the kernel values to sum to 1.


Returns a rotated kernel.

    Args:
      rotations: Number of 90 degree rotations to make. Negative numbers rotate
        counterclockwise.


Returns a 3x3 Sobel edge-detection kernel.

    Args:
      magnitude: Scale each value by this amount.
      normalize: Normalize the kernel values to sum to 1.


Returns a square-shaped boolean kernel.

    Args:
      radius: The radius of the kernel to generate.
      units: The system of measurement for the kernel ('pixels' or 'meters'). If
        the kernel is specified in meters, it will resize when the zoom-level is
        changed.
      normalize: Normalize the kernel values to sum to 1.
      magnitude: Scale each value by this amount.


Convert a datetime to a timestamp, microseconds since the epoch.


Encodes a top level object to be executed server-side.

    Args:
      obj: The object to encode.

    Returns:
      An encoded object ready for JSON serialization.


Encodes an object as an Expression or quasi-Expression.


Encodes a subtree as a Value in the EE API v2 (DAG) format.

    If _is_compound is True, this will fill the _scope and _encoded properties.

    Args:
      obj: The object to encode.

    Returns:
      An encoded object.


Encodes an object using the Cloud API Expression form.

    If _is_compound is True, this will fill the _scope and _encoded properties.

    Args:
      obj: The object to encode.

    Returns:
      If _is_compound is True, a string that is the key under which the
        encoded object is stored in _scope.
      If _is_compound is False, the encoded object as a single quasi-Expression.


Serialize an object to a JSON-compatible structure for API calls.

  Args:
    obj: The object to serialize.
    is_compound: Whether the encoding should factor out shared subtrees.
    for_cloud_api: Whether the encoding should be done for the Cloud API or the
      legacy API.
    unbound_name: Provides a name for unbound variables in objects. Unbound
      variables are otherwise disallowed. See the Count Functions usage in
      customfunction.py.

  Returns:
    A JSON-compatible structure representing the input.


Serialize an object to a JSON string appropriate for API calls.

  Args:
    obj: The object to serialize.
    pretty: True to pretty-print the object.
    for_cloud_api: Whether the encoding should be done for the Cloud API or the
      legacy API.

  Returns:
    A JSON string representing the input.


Finds the names of all named values that are referred to only once.


Gets a contained reference from a ValueNode, if there is one.


Optimises the expression, returning the optimised form.


Recursively optimises a value.

    Optimises a value and everything recursively reachable from it.

    This operates differently depending on the mode.
    In compound mode:
      Takes a name (in _values) for a ValueNode, optimises the referenced
      ValueNode, and returns a name (in _optimized_values) for the optimised
      ValueNode. Updates _optimized_values and _reference_map.
    In non-compound mode:
      Takes a quasi-ValueNode, optimises it, and returns the optimised
      quasi-ValueNode.

    Args:
      reference_or_value: The name in _values of the value to optimise, or the
        actual value itself.

    Returns:
      The name, in _optimized_values, of the optimised value, or the optimised
      value itself.


Optimises a single value.

    Args:
      value: The ValueNode to optimise, in dict form.
      depth: How deep in the encoded output this value will be placed.

    Returns:
      An optimised version of that value, created by lifting in all feasible
      constants and references, subject (in compound mode) to a depth limit.


Determines if a value is simple enough to lift unconditionally.


Calls visitor on all ValueNodes in the expression.

    Args:
      visitor: A callable that will be invoked once at every ValueNode in the
        expression, including nested ValueNodes.


Calls visitor on a ValueNode and its descendants.

    Args:
      reference: A reference to the ValueNode, or None.
      value: The ValueNode, in dict form.
      visited: A set of references for which the visitor has already been
        invoked.
      visitor: The callable to invoke.


Uses authorization code to request tokens.


Attempts to write the passed token to the given user directory.


Tests if the code is being executed within Google Colab.


Tests if the code is being executed within Jupyter.


Returns the project number associated with the given OAuth client ID.


Obtains and writes credentials token based on an authorization code.


Displays instructions for authenticating without blocking for user input.


Displays instructions for authenticating using a print statement.


Displays instructions for authenticating using HTML code.


Makes random nonces, and adds PKCE challenges for each _verifier nonce.


Opens a web browser if possible, returning True when so.


Initializes credentials by running gcloud flows.


Starts and returns a web server that handles the OAuth callback.


Prompts the user to authorize access to Earth Engine via OAuth2.

  Args:
    cli_authorization_code: An optional authorization code.  Supports CLI mode,
      where the code is passed as an argument to `earthengine authenticate`.
    quiet: If true, do not require interactive prompts and force --no-browser
      mode for gcloud-legacy. If false, never supply --no-browser. Default is
      None, which autodetects the --no-browser setting.
    cli_code_verifier: PKCE verifier to prevent auth code stealing.  Must be
      provided if cli_authorization_code is given.
    auth_mode: The authorization mode.  One of:
        "colab" - use the Colab authentication flow.
        "notebook" - send user to notebook authenticator page. Intended for
          web users who do not run code locally. Credentials expire in 7 days.
        "gcloud" - use gcloud to obtain credentials.
        "localhost" - sends credentials to the Python environment on the same
          localhost as the browser. Does not work for remote shells. Default
          port is 8085; use localhost:N set port or localhost:0 to auto-select.
        "gcloud-legacy" - included for legacy compatibility but not materially
          different from "gcloud".
        "appdefault" - included for legacy compatibility but not necessary.
          ee.Initialize() will always check for application default credentials.
        None - a default mode is chosen based on your environment.
   scopes: List of scopes to use for authorization. Defaults to [
     'https://www.googleapis.com/auth/earthengine',
     'https://www.googleapis.com/auth/cloud-platform',
     'https://www.googleapis.com/auth/drive',
     'https://www.googleapis.com/auth/devstorage.full_control' ].
   force: Will force authentication even if valid credentials already exist.

  Returns:
    True if we found valid credentials and didn't run the auth flow, or
    otherwise None.

  Raises:
     Exception: on invalid arguments.


Fetches auth code if not given, and saves the generated credentials.


Prints to stdout, and returns True if a browser should be opened.


Decorator to maintain support for "opt_" prefixed kwargs.

  Args:
    *opt_args: Arguments prefixed with "opt_" to be replaced by the stripped
      version. Use a nested tuple to map an old "opt_" arg to a new one, e.g.,
      `opt_my_arg, (opt_my_arg2, opt_new_name)`.

  Returns:
    The decorated function which accepts the "opt_" versions of the args.


Return the number of predicates that have been added to this filter.

    Returns:
      The number of predicates that have been added to this filter.
      This does not count nested predicates.


Append a predicate to this filter.

    These are implicitly ANDed.

    Args:
      new_filter: The filter to append to this one.  Possible types are:
          1) another fully constructed Filter,
          2) a JSON representation of a filter,
          3) an array of 1 or 2.

    Returns:
      A new filter that is the combination of both.


Filter on metadata. This is deprecated.

    Args:
      name: The property name to filter on.
      operator: The type of comparison. One of:
          "equals", "less_than", "greater_than", "contains", "begins_with",
          "ends_with", or any of these prefixed with "not_".
      value: The value to compare against.

    Returns:
      The new filter.

    Deprecated.  Use ee.Filter.eq(), ee.Filter.gte(), etc.'


Combine two or more filters using boolean AND.


Returns an area filter of the geometry.

    Returns a filter that passes if the specified geometry has an area within
    the given range (inclusive).

    Args:
      min: Minimum area in square meters (inclusive).
      max: Maximum area in square meters (inclusive).
      maxError: The maximum allowed error for computing the geometry's area.
      geometrySelector: The name of the geometry property to use for filtering.
        Leave blank or use '.geo' to operate on the object's geometry.


Returns a filter that passes if a date range contains a date.

    Creates a unary or binary filter that passes if the left operand, a date
    range, contains the right operand, a date.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.


Returns a filter on intersection with geometry.

    Items in the collection with a footprint that fails to intersect
    the given geometry will be excluded. This is an alias for geometry().

    Caution: providing a large or complex collection as the `geometry` argument
    can result in poor performance. Collating the geometry of collections does
    not scale well; use the smallest collection (or geometry) that is required
    to achieve the desired outcome.

    Args:
      geometry: The geometry to filter to either as a GeoJSON geometry, or a
        FeatureCollection, from which a geometry will be extracted.
      errorMargin: An optional error margin. If a number, interpreted as sphere
        surface meters.


Returns a filter that passes if a timestamp is in a range.

    Returns a filter that passes if the object's timestamp falls within the
    given range of a calendar field.

    The `month`, `day_of_year`, `day_of_month`, and `day_of_week` are 1-based.
    Times are assumed to be in UTC. Weeks are assumed to begin on Monday as day
    1. If `end` < `start` then this tests for `value` >= `start` OR `value` <=
    `end`, to allow for wrapping.

    Args:
      start: The start of the desired calendar field, inclusive.
      end: The end of the desired calendar field, inclusive. Defaults to the
        same value as start.
      field: The calendar field to filter over. Options are: `year`, `month`,
        `hour`, `minute`, `day_of_year`, `day_of_month`, and `day_of_week`.


Returns a filter that passes if the left contains the right geometry.

    Creates a unary or binary filter that passes if the left geometry contains
    the right geometry (empty geometries are not contained in anything).

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.
      maxError: The maximum reprojection error allowed during filter
        application.


Filter images by date.

    The start and end may be a Date, numbers (interpreted as milliseconds since
    1970-01-01T00:00:00Z), or strings (such as '1996-01-01T08:00'). Based on
    'system:time_start'.

    Args:
      start: The inclusive start date.
      end: The optional exclusive end date, If not specified, a 1-millisecond
        range starting at 'start' is created.

    Returns:
      The modified filter.


Returns a day-of-year filter.

    Returns a filter that passes if the object's timestamp falls within the
    given day-of-year range.

    Args:
      start: The start of the desired day range, inclusive.
      end: The end of the desired day range, inclusive.


Returns a filter.

    Creates a unary or binary filter that passes unless the left geometry
    intersects the right geometry.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.
      maxError: The maximum reprojection error allowed during filter
        application.


Returns a filter that passes if the two operands are equals.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.


Returns a filter tree from a string.

    Args:
      expression: A string to be parsed into a Filter object (e.g., "property >
        value"). Supported operators include: >, >=, <, <=, ==, !=, (), !, &&
        and ||.


Filter on intersection with geometry.

    Items in the collection with a footprint that fails to intersect
    the given geometry will be excluded.

    Args:
      geometry: The geometry to filter to either as a GeoJSON geometry, or a
        FeatureCollection, from which a geometry will be extracted.
      errorMargin: An optional error margin. If a number, interpreted as sphere
        surface meters.

    Returns:
      The constructed filter.


Returns a filter that passes if value is greater than the right operand.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.


Returns filter that passes if value is greater than the right operand.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.


Returns a filter that passes if the left has the type.

    Creates a unary or binary filter that passes if the left operand has the
    type, or is a subtype of the type named in the right operand.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.

    Returns:
      An ee.Filter.


Returns a filter that passes if left intersects the right geometry.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.
      maxError: The maximum reprojection error allowed during filter
        application.


Returns filter that passes if the right geometry contains the geometry.

    Empty geometries are not contained in anything.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.
      maxError: The maximum reprojection error allowed during filter
        application.


Filter on metadata contained in a list.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.

    Returns:
      The constructed filter.


Returns filter that passes if the value is less than the right operand.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.


Returns filter that passes if the left, contains the right.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.

    Returns:
      An ee.Filter.


Returns a filter that passes if the fields are within a given difference.

    Creates a unary or binary filter that passes if the left and right operands,
    both numbers, are within a given maximum difference.

    If used as a join condition, this numeric difference is used as a join
    measure.

    Args:
      difference: The maximum difference for which the filter will return true.
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.


Returns a filter that passes unless the two operands are equal.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.


Returns the opposite of this filter.

    Returns:
      The negated filter, which will match if and only if this filter does not.


Combine two or more filters using boolean OR.


Returns a filter that passes if the value is in the range.

    Returns a filter that passes if the value of the selected field is in the
    specified range (inclusive).

    Args:
      field: A selector for the property being tested.
      minValue: The lower bound of the range.
      maxValue: The upper bound of the range.


Returns a filter that passes if it contains the right string.

    Creates a unary or binary filter that passes if the left operand, a string,
    contains the right operand, also a string.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.


Returns a filter that passes if the string ends with the right string.

    Creates a unary or binary filter that passes if the left operand, a string,
    ends with the right operand, also a string.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.


Returns a filter that passes if the string starts with the right string.

    Creates a unary or binary filter that passes if the left operand, a string,
    starts with the right operand, also a string.

    Args:
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.


Returns a filter that passes if the geometry is within a distance.

    Creates a unary or binary filter that passes if the left geometry is within
    a specified distance of the right geometry. If used as a join condition,
    this distance is used as a join measure.

    Args:
      distance: The maximum distance for which the filter will return true.
      leftField: A selector for the left operand. Should not be specified if
        leftValue is specified.
      rightValue: The value of the right operand. Should not be specified if
        rightField is specified.
      rightField: A selector for the right operand. Should not be specified if
        rightValue is specified.
      leftValue: The value of the left operand. Should not be specified if
        leftField is specified.
      maxError: The maximum reprojection error allowed during filter
        application.


Accumulates elements of an array along the given axis.

    Sets each element of the result to the reduction of elements along that axis
    up to and including the current position.

    May be used to make a cumulative sum, a monotonically increasing sequence,
    etc.

    Args:
      axis: Axis along which to perform the accumulation.
      reducer: Reducer to accumulate values. Default is SUM, to produce the
        cumulative sum of each vector along the given axis.

    Returns:
      An ee.Array.


On an element-wise basis, adds the first value to the second.

    Args:
      right: The values to add.

    Returns:
      An ee.Array.


Returns 1 if both values are non-zero.

    Args:
      right: The values to add.

    Returns:
      An ee.Array.


Returns the position of the maximum value in an array.

    If there are multiple occurrences of the maximum, returns the position of
    the first.

    Returns:
      An ee.List that is empty if the input in an empty ee.Array.


Calculates the angle formed by the 2D vector [x, y].

    Args:
      right: The y values.

    Returns:
      An ee.Array.


Calculates the number of one-bits.

    Uses a 64-bit two's complement binary representation of the input.

    Returns:
      An ee.Array.


Returns an Array from the bits of an integer.

    The array has as many elements as the position of the highest set bit, or a
    single 0 for a value of 0.

    Args:
      input: The integer to transform.


On an element-wise basis, calculates the bitwise AND of the input values.

    Args:
      right: The values to AND with.

    Returns:
      An ee.Array.


On an element-wise basis, calculates the bitwise NOT of the input.

    In the smallest signed integer type that can hold the input.

    Returns:
      An ee.Array.


On an element-wise basis, calculates the bitwise OR of the input values.

    Args:
      right: The values to OR with.

    Returns:
      An ee.Array.


On an element-wise basis, calculates the bitwise XOR of the input values.

    Args:
      right: The values to XOR with.

    Returns:
      An ee.Array.


Returns an Array that is the concatenation of the given arrays.

    Concatenates multiple arrays into a single array along the given axis. Each
    array must have the same dimensionality and the same length on all axes
    except the concatenation axis.

    Args:
      arrays: Arrays to concatenate.
      axis: Axis to concatenate along. Defaults to 0.


Cut an array along one or more axes.

    Args:
      position: Cut an array along one or more axes. The positions args
        specifies either a single value for each axis of the array, or -1,
        indicating the whole axis. The output will be an array that has the same
        dimensions as the input, with a length of 1 on each axis that was not -1
        in the positions array.

    Returns:
      An ee.Array.


Divides the first value by the second, returning 0 for division by 0.

    Args:
      right: The values to divide by.

    Returns:
      An ee.Array.


Compute the dot product between two 1-D arrays.

    Args:
      array2: The second 1-D array.

    Returns:
      An ee.Number.


Computes the real eigenvectors and eigenvalues of a square 2D array.

    Returns:
      An ee.Array with A rows and A+1 columns, where each row contains an
      eigenvalue in the first column, and the corresponding eigenvector in the
      remaining A columns. The rows are sorted by eigenvalue, in descending
      order. This implementation uses DecompositionFactory.eig() from
      http://ejml.org.


Returns 1 if the first value is equal to the second.

    Args:
      right: The values to compare with.

    Returns:
      An ee.Array.


On an element-wise basis, selects the value of the first value.

    Args:
      right: The matching values that are always ignored.

    Returns:
      An ee.Array.


Selects the first value if it is non-zero, otherwise the second value.

    Args:
      right: The values to use if the array has a zero in the corresponding
        position.

    Returns:
      An ee.Array.


Returns 1 if the first value is greater than the second.

    Args:
      right: The values to compare with.

    Returns:
      An ee.Array.


Returns 1 if the first value is greater than or equal to the second.

    Args:
      right: The values to compare with.

    Returns:
      An ee.Array.


Calculates the magnitude of the 2D vector [x, y].

    Args:
      right: The y values.

    Returns:
      An ee.Array.


Returns a 2D identity matrix of the given size.

    Args:
      size: The length of each axis.


On an element-wise basis, calculates the left shift of v1 by v2 bits.

    Args:
      right: How many bits to shift by.

    Returns:
      An ee.Array.


Returns 1 if the first value is less than the second.

    Args:
      right: The values to compare with.

    Returns:
      An ee.Array.


Returns 1 if the first value is less than or equal to the second.

    Args:
      right: The values to compare with.

    Returns:
      An ee.Array.


Creates an array of just the elements that have non-zero mask matches.

    Creates a subarray by slicing out each position in an input array that is
    parallel to a non-zero element of the given mask array.

    Args:
      mask: Mask array.

    Returns:
      An ee.Array.


Calculates the Cholesky decomposition of a matrix.

    The Cholesky decomposition is a decomposition into the form L * L' where L
    is a lower triangular matrix. The input must be a symmetric
    positive-definite matrix. Returns a dictionary with 1 entry named 'L'.

    Returns:
      An ee.Dictionary.


Returns the matrix multiplication A * B.

    Args:
      right: The right-hand value.

    Returns:
      An ee.Array.


Returns the QR decomposition of the input matrix.

    Calculates the QR-decomposition of a matrix into two matrices Q and R such
    that input = QR, where Q is orthogonal, and R is upper triangular.

    Returns a dictionary with entries named 'Q' and 'R'.

    Returns:
      An ee.Dictionary.


Returns the least-squares solution of the input matrix.

    Solves for x in the matrix equation A * x = B, finding a least-squares
    solution if A is overdetermined.

    Args:
      right: The right-hand value.

    Returns:
      An ee.Array.


Transposes two dimensions of an array.

    Args:
      axis1: First axis to swap. Defaults to 0.
      axis2: Second axis to swap. Defaults to 1.

    Returns:
      An ee.Array.


Selects the maximum of the first and second values.

    Args:
      right: The values to compare with.

    Returns:
      An ee.Array.


Selects the minimum of the first and second values.

    Args:
      right: The values to compare with.

    Returns:
      An ee.Array.


Calculates the remainder of the first value divided by the second.

    Args:
      right: The values to divide by.

    Returns:
      An ee.Array.


On an element-wise basis, multiplies the first value by the second.

    Args:
      right: The values to multiply by.

    Returns:
      An ee.Array.


Returns 1 if the first value is not equal to the second.

    Args:
      right: The right-hand value.

    Returns:
      An ee.Array.


On an element-wise basis, returns 1 if either input value is non-zero.

    Args:
      right: The right-hand value.

    Returns:
      An ee.Array.


Pad an array to a given length.

    The pad value will be repeatedly appended to the array to extend it to given
    length along each axis. If the array is already as large or larger than a
    given length, it will remain unchanged along that axis.

    Args:
      lengths: A list of new lengths for each axis.
      pad: The value with which to pad the array. Defaults to 0.

    Returns:
      An ee.Array.


On an element-wise basis, raises the first value to the power of the second.

    Args:
      right: The right-hand value.

    Returns:
      An ee.Array.


Returns the projected array.

    Projects an array to a lower dimensional space by specifying the axes to
    retain. Dropped axes must be at most length 1.

    Args:
      axes: The axes to project onto. Other axes will be discarded, and must be
        at most length 1.

    Returns:
      An ee.Array.


Returns the result of applying the reducer on the array.

    Apply a reducer to an array by collapsing all the input values along each
    specified axis into a single output value computed by the reducer.

    The output always has the same dimensionality as the input, and the
    individual axes are affected as follows:

    - The axes specified in the 'axes' parameter have their length reduced to 1
      (by applying the reducer).
    - If the reducer has multiple inputs or multiple outputs, the axis specified
      in 'fieldAxis' will be used to provide the reducer's inputs and store the
      reducer's outputs.
    - All other axes are unaffected (independent reductions are performed).

    Args:
      reducer: The reducer to apply. Each of its outputs must be a number, not
        an array or other type.
      axes: The list of axes over which to reduce. The output will have a length
        of 1 in all these axes.
      fieldAxis: The axis to use as the reducer's input and output fields. Only
        required if the reducer has multiple inputs or multiple outputs, in
        which case the axis must have length equal to the number of reducer
        inputs, and in the result it will have length equal to the number of
        reducer outputs.

    Returns:
      An ee.Array.


Repeats the array along the given axis.

    The result will have the shape of the input, except length along the
    repeated axis will be multiplied by the given number of copies.

    Args:
      axis: The axis along which to repeat the array. Defaults to 0.
      copies: The number of copies of this array to concatenate along the given
        axis. Defaults to 2.

    Returns:
      An ee.Array.


Reshapes an array to a new list of dimension lengths.

    Args:
      shape: New shape to which arrays are converted. If one component of the
        shape is the special value -1, the size of that dimension is computed so
        that the total size remains constant. In particular, a shape of [-1]
        flattens into 1-D. At most one component of shape can be -1.

    Returns:
      An ee.Array.


Calculates the signed right shift of v1 by v2 bits.

    Args:
      right: The values to shift by.

    Returns:
      An ee.Array.


Returns -1 or 1 base on the sign of the input or 0 if the input is zero.

    On an element-wise basis, computes the signum function (sign) of the input;
    The return value is 0 if the input is 0, 1 if the input is greater than 0,
    -1 if the input is less than 0.

    Returns:
      An ee.Array.


Returns the result of slicing the array along the given axis.

    Creates a subarray by slicing out each position along the given axis from
    the 'start' (inclusive) to 'end' (exclusive) by increments of 'step'.

    The result will have as many dimensions as the input, and the same length in
    all directions except the slicing axis, where the length will be the number
    of positions from 'start' to 'end' by 'step' that are in range of the input
    array's length along 'axis'. This means the result can be length 0 along the
    given axis if start=end, or if the start or end values are entirely out of
    range.

    Args:
      axis: The axis to slice on. Defaults to 0.
      start: The coordinate of the first slice (inclusive) along 'axis'.
        Negative numbers are used to position the start of slicing relative to
        the end of the array, where -1 starts at the last position on the axis,
        -2 starts at the next to last position, etc.  Defaults to 0.
      end: The coordinate (exclusive) at which to stop taking slices. By default
        this will be the length of the given axis. Negative numbers are used to
        position the end of slicing relative to the end of the array, where -1
        will exclude the last position, -2 will exclude the last two positions,
        etc.
      step: The separation between slices along 'axis'; a slice will be taken at
        each whole multiple of 'step' from 'start' (inclusive) to 'end'
        (exclusive). Must be positive.  Defaults to 1.

    Returns:
      An ee.Array.


Sorts elements of the array along one axis.

    Args:
      keys: Optional keys to sort by. If not provided, the values are used as
        the keys. The keys can only have multiple elements along one axis, which
        determines the direction to sort in.

    Returns:
      An ee.Array.


On an element-wise basis, subtracts the second value from the first.

    Args:
      right: The values to subtract.

    Returns:
      An ee.Array.


Joins two collections.

    Args:
      primary: The primary collection.
      secondary: The secondary collection.
      condition: The join condition used to select the matches from the two
        collections.

    Returns:
      An ee.FeatureCollection.


Returns a join with matching pairs of elements.

    Returns a join that pairs elements from the primary collection with matching
    elements from the secondary collection.

    Each result has a 'primary' property that contains the element from the
    primary collection, and a 'secondary' property containing the matching
    element from the secondary collection. If measureKey is specified, the join
    measure is also attached to the object as a property.

    Args:
      primaryKey: The property name used to save the primary match.
      secondaryKey: The property name used to save the secondary match.
      measureKey: An optional property name used to save the measure of the join
        condition.