LocationService / Paginator / ListGeofences

ListGeofences#

class LocationService.Paginator.ListGeofences#

paginator = client.get_paginator('list_geofences')

paginate(**kwargs)#

Creates an iterator that will paginate through responses from LocationService.Client.list_geofences().

Request Syntax

response_iterator = paginator.paginate(
    CollectionName='string',
    PaginationConfig={
        'MaxItems': 123,
        'PageSize': 123,
        'StartingToken': 'string'
    }
)

Parameters:

CollectionName (string) –
[REQUIRED]

The name of the geofence collection storing the list of geofences.
PaginationConfig (dict) –
A dictionary that provides parameters to control pagination.
- MaxItems (integer) –
  
  The total number of items to return. If the total number of items available is more than the value specified in max-items then a NextToken will be provided in the output that you can use to resume pagination.
- PageSize (integer) –
  
  The size of each page.
- StartingToken (string) –
  
  A token to specify where to start paginating. This is the NextToken from a previous response.

Return type:

dict

Returns:

Response Syntax

{
    'Entries': [
        {
            'GeofenceId': 'string',
            'Geometry': {
                'Polygon': [
                    [
                        [
                            123.0,
                        ],
                    ],
                ],
                'Circle': {
                    'Center': [
                        123.0,
                    ],
                    'Radius': 123.0
                },
                'Geobuf': b'bytes'
            },
            'Status': 'string',
            'CreateTime': datetime(2015, 1, 1),
            'UpdateTime': datetime(2015, 1, 1),
            'GeofenceProperties': {
                'string': 'string'
            }
        },
    ],

}

Response Structure

(dict) –
- Entries (list) –
  
  Contains a list of geofences stored in the geofence collection.
  - (dict) –
    
    Contains a list of geofences stored in a given geofence collection.
    
    Note
    The returned geometry will always match the geometry format used when the geofence was created.
    - GeofenceId (string) –
      
      The geofence identifier.
    - Geometry (dict) –
      
      Contains the geofence geometry details describing a polygon or a circle.
      - Polygon (list) –
        
        A polygon is a list of linear rings which are each made up of a list of vertices.
        
        Each vertex is a 2-dimensional point of the form: [longitude, latitude]. This is represented as an array of doubles of length 2 (so [double, double]).
        
        An array of 4 or more vertices, where the first and last vertex are the same (to form a closed boundary), is called a linear ring. The linear ring vertices must be listed in counter-clockwise order around the ring’s interior. The linear ring is represented as an array of vertices, or an array of arrays of doubles ( [[double, double], ...]).
        
        A geofence consists of a single linear ring. To allow for future expansion, the Polygon parameter takes an array of linear rings, which is represented as an array of arrays of arrays of doubles ( [[[double, double], ...], ...]).
        
        A linear ring for use in geofences can consist of between 4 and 1,000 vertices.
        
        (list) –
        
        (list) –
        
        (float) –
      - Circle (dict) –
        
        A circle on the earth, as defined by a center point and a radius.
        
        Center (list) –
        
        A single point geometry, specifying the center of the circle, using WGS 84 coordinates, in the form [longitude, latitude].
        
        (float) –
        
        Radius (float) –
        
        The radius of the circle in meters. Must be greater than zero and no larger than 100,000 (100 kilometers).
      - Geobuf (bytes) –
        
        Geobuf is a compact binary encoding for geographic data that provides lossless compression of GeoJSON polygons. The Geobuf must be Base64-encoded.
        
        A polygon in Geobuf format can have up to 100,000 vertices.
    - Status (string) –
      
      Identifies the state of the geofence. A geofence will hold one of the following states:
      - ACTIVE — The geofence has been indexed by the system.
      - PENDING — The geofence is being processed by the system.
      - FAILED — The geofence failed to be indexed by the system.
      - DELETED — The geofence has been deleted from the system index.
      - DELETING — The geofence is being deleted from the system index.
    - CreateTime (datetime) –
      
      The timestamp for when the geofence was stored in a geofence collection in ISO 8601 format: YYYY-MM-DDThh:mm:ss.sssZ
    - UpdateTime (datetime) –
      
      The timestamp for when the geofence was last updated in ISO 8601 format: YYYY-MM-DDThh:mm:ss.sssZ
    - GeofenceProperties (dict) –
      
      User defined properties of the geofence. A property is a key-value pair stored with the geofence and added to any geofence event triggered with that geofence.
      
      Format: "key" : "value"
      - (string) –
        
        (string) –