arcgis.layers module

Bases: Layer

The SceneLayer class represents a Web scene layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

from arcgis.layers import SceneLayer
s_layer = SceneLayer(url='https://your_portal.com/arcgis/rest/services/service_name/SceneServer/')

type(s_layer)
>> arcgis.layers.PointCloudLayer

print(s_layer.properties.layers[0].name)
>> 'your layer name'

Bases: _GISResource

The SceneLayerManager class allows administration (if access permits) of ArcGIS Online hosted scene layers. A SceneLayerManager offers access to map and layer content.

cancel_job(job_id: str) → dict | None

The cancel_job operation supports cancelling a job while update tiles is running from a hosted feature service. The result of this operation is a response indicating success or failure with error code and description.

Parameter	Description
job_id	Required String. The job id to cancel.

edit(item: str | Item) → dict | None

The edit method edits from an Item object.

Parameter	Description
item	Required ItemId or Item object. The TPK file’s item id. This TPK file contains to-be-extracted bundle files which are then merged into an existing cache service.

Returns:

A dictionary

import_package(item: str | Item) → dict | None

The import method imports from an Item object.

Parameter	Description
item	Required ItemId or Item object. The TPK file’s item id. This TPK file contains to-be-extracted bundle files which are then merged into an existing cache service.

Returns:

A dictionary

job_statistics(job_id: str) → dict | None

Returns the job statistics for the given jobId

jobs() → dict | None

The tile service job summary (jobs) resource represents a summary of all jobs associated with a vector tile service. Each job contains a jobid that corresponds to the specific jobid run and redirects you to the Job Statistics page.

rebuild_cache(layers: int | list[int]) → dict | None

The rebuild_cache operation update the scene layer cache to reflect any changes made to the feature layer used to publish this scene layer. The results of the operation is a response indicating success, which redirects you to the Job Statistics page, or failure.

Parameter	Description
layers	Required int or list of int. Comma separated values indicating the id of the layers to rebuild in the cache. Ex: [0,1,2]

refresh() → dict | None

The refresh operation refreshes a service, which clears the web server cache for the service.

rerun_job(job_id: str, code: str) → dict | None

The rerun_job operation supports re-running a canceled job from a hosted map service. The result of this operation is a response indicating success or failure with error code and description.

Parameter	Description
code	Required string, parameter used to re-run a given jobs with a specific error code: ALL | ERROR | CANCELED
job_id	Required string, job to reprocess

Returns:

A boolean or dictionary

swap(target_service_name: str) → dict | None

The swap operation replaces the current service cache with an existing one.

Note

The swap operation is for ArcGIS Online only.

Parameter	Description
target_service_name	Required string. Name of service you want to swap with.

Returns:

dictionary indicating success or error

update() → dict | None

The update method starts update generation for ArcGIS Online. It updates the underlying source dataset for the service, essentially refreshing the underlying package data.

Returns:

Dictionary.

update_attribute(layers: int | list[int]) → dict | None

Update atrribute is a “light rebuild” where attributes of the layers selected are updated and can be used for change tracking. The results of the operation is a response indicating success, which redirects you to the Job Statistics page, or failure.

Parameter	Description
layers	Required int or list of int. Comma separated values indicating the id of the layers to update in the cache. Ex: [0,1,2]

update_cache(layers: int | list[int]) → dict | None

Update Cache is a “light rebuild” where attributes and geometries of the layers selected are updated and can be used for change tracking on the feature layer to only update nodes with dirty tiles. The results of the operation is a response indicating success, which redirects you to the Job Statistics page, or failure.

Parameter	Description
layers	Required int or list of int. Comma separated values indicating the id of the layers to update in the cache. Ex: [0,1,2]

Bases: _GISResource

The EnterpriseSceneLayerManager class allows administration (if access permits) of ArcGIS Enterprise hosted scene layers. A SceneLayer offers access to layer content.

change_provider(provider: str)

Allows for the switching of the service provide and how it is hosted on the ArcGIS Server instance.

Values:

• ‘ArcObjects’ means the service is running under the ArcMap runtime i.e. published from ArcMap

• ‘ArcObjects11’: means the service is running under the ArcGIS Pro runtime i.e. published from ArcGIS Pro

• ‘DMaps’: means the service is running in the shared instance pool (and thus running under the ArcGIS Pro provider runtime)

Returns:

Boolean

delete()

deletes a service from arcgis server

edit(service_dictionary: dict)

To edit a service, you need to submit the complete JSON representation of the service, which includes the updates to the service properties. Editing a service causes the service to be restarted with updated properties.

Returns:

boolean

rebuild_cache(layer: list[int] | None = None, extent: dict | None = None, area_of_interest: dict | None = None) → str

The rebuild_cache operation update the scene layer cache to reflect any changes made to the feature layer used to publish this scene layer. The results of the operation is the url to the scene service once it is done rebuilding.

Parameter	Description
layer	Optional list of integers. The list of layers to cook.
extent	Optional dict. The updated extent to be used. If nothing is specified, the default extent is used.
area_of_interest	Optional dict representing a feature. Specify the updated area of interest. Syntax: { “displayFieldName”: “”, “geometryType”: “esriGeometryPolygon”, “spatialReference”: { “wkid”: 54051, “latestWkid”: 54051 }, “fields”: [ { “name”: “OID”, “type”: “esriFieldTypeOID”, “alias”: “OID” }, { “name”: “updateGeom_Length”, “type”: “esriFieldTypeDouble”, “alias”: “updateGeom_Length” }, { “name”: “updateGeom_Area”, “type”: “esriFieldTypeDouble”, “alias”: “updateGeom_Area” } ], “features”: [], “exceededTransferLimit”: False }

Returns:

If successful, the url to the scene service

start()

starts the specific service

stop()

stops the specific service

update_attribute(layer: list[int] | None = None, extent: dict | None = None, area_of_interest: dict | None = None) → str

Update attribute is a “light rebuild” where attributes of the layers selected are updated and can be used for change tracking. The results of the operation is the url to the scene service once it is done updating.

Parameter	Description
layer	Optional list of integers. The list of layers to cook.
extent	Optional dict. The updated extent to be used. If nothing is specified, the default extent is used.
area_of_interest	Optional dict representing a feature. Specify the updated area of interest. Syntax: { “displayFieldName”: “”, “geometryType”: “esriGeometryPolygon”, “spatialReference”: { “wkid”: 54051, “latestWkid”: 54051 }, “fields”: [ { “name”: “OID”, “type”: “esriFieldTypeOID”, “alias”: “OID” }, { “name”: “updateGeom_Length”, “type”: “esriFieldTypeDouble”, “alias”: “updateGeom_Length” }, { “name”: “updateGeom_Area”, “type”: “esriFieldTypeDouble”, “alias”: “updateGeom_Area” } ], “features”: [], “exceededTransferLimit”: false }

Returns:

If successful, the url to the scene service

update_cache(layer: list[int] | None = None, extent: dict | None = None, area_of_interest: dict | None = None) → str

Update Cache is a “light rebuild” where attributes and geometries of the layers selected are updated and can be used for change tracking on the feature layer to only update nodes with dirty tiles,. The results of the operation is the url to the scene service once it is done updating.

Parameter	Description
layer	Optional list of integers. The list of layers to cook.
extent	Optional dict. The updated extent to be used. If nothing is specified, the default extent is used.
area_of_interest	Optional dict representing a feature. Specify the updated area of interest. Syntax: { “displayFieldName”: “”, “geometryType”: “esriGeometryPolygon”, “spatialReference”: { “wkid”: 54051, “latestWkid”: 54051 }, “fields”: [ { “name”: “OID”, “type”: “esriFieldTypeOID”, “alias”: “OID” }, { “name”: “updateGeom_Length”, “type”: “esriFieldTypeDouble”, “alias”: “updateGeom_Length” }, { “name”: “updateGeom_Area”, “type”: “esriFieldTypeDouble”, “alias”: “updateGeom_Area” } ], “features”: [], “exceededTransferLimit”: False }

Returns:

If successful, the url to the scene service

Bases: Layer

The BuildingLayer class represents a Web building layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

from arcgis.layers import SceneLayer
s_layer = SceneLayer(url='https://your_portal.com/arcgis/rest/services/service_name/SceneServer/')

type(s_layer)
>> arcgis.layers.BuildingLayer

print(s_layer.properties.layers[0].name)
>> 'your layer name'

property manager: SceneLayerManager | EnterpriseSceneLayerManager

The manager property returns an instance of SceneLayerManager class or EnterpriseSceneLayerManager class which provides methods and properties for administering this service.

Bases: Layer

The IntegratedMeshLayer class represents a Web scene Integrated Mesh layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

from arcgis.layers import SceneLayer
s_layer = SceneLayer(url='https://your_portal.com/arcgis/rest/services/service_name/SceneServer/')

type(s_layer)
>> arcgis.layers.Point3DLayer

print(s_layer.properties.layers[0].name)
>> 'your layer name'

property manager: SceneLayerManager | EnterpriseSceneLayerManager

The manager property returns an instance of SceneLayerManager class or EnterpriseSceneLayerManager class which provides methods and properties for administering this service.

Bases: Layer

The Tiles3DLayer class represents a Web scene 3D Tile Service Layer.

property manager: Tiles3DLayerManager

The manager property returns an instance of Tiles3DLayerManager class which provides methods and properties for administering this service.

Bases: Layer

The Object3DLayer represents a Web scene 3D Object layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

from arcgis.layers import SceneLayer
s_layer = SceneLayer(url='https://your_portal.com/arcgis/rest/services/service_name/SceneServer/')

type(s_layer)
>> arcgis.layers.Point3DLayer

print(s_layer.properties.layers[0].name)
>> 'your layer name'

property manager: SceneLayerManager | EnterpriseSceneLayerManager

The manager property returns an instance of SceneLayerManager class or EnterpriseSceneLayerManager class which provides methods and properties for administering this service.

Bases: Layer

The Point3DLayer class represents a Web scene 3D Point layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

from arcgis.layers import SceneLayer
s_layer = SceneLayer(url='https://your_portal.com/arcgis/rest/services/service_name/SceneServer/')

type(s_layer)
>> arcgis.layers.Point3DLayer

print(s_layer.properties.layers[0].name)
>> 'your layer name'

property manager: SceneLayerManager | EnterpriseSceneLayerManager

The manager property returns an instance of SceneLayerManager class or EnterpriseSceneLayerManager class which provides methods and properties for administering this service.

Bases: Layer

The PointCloudLayer class represents a Web scene Point Cloud layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

from arcgis.layers import SceneLayer
s_layer = SceneLayer(url='https://your_portal.com/arcgis/rest/services/service_name/SceneServer/')

type(s_layer)
>> arcgis.layers.PointCloudLayer

print(s_layer.properties.layers[0].name)
>> 'your layer name'

property manager: SceneLayerManager | EnterpriseSceneLayerManager

The manager property returns an instance of SceneLayerManager class or EnterpriseSceneLayerManager class which provides methods and properties for administering this service.

Bases: Layer

The VoxelLayer class represents a Web Scene Voxel layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

from arcgis.layers import SceneLayer
s_layer = SceneLayer(url='https://your_portal.com/arcgis/rest/services/service_name/SceneServer/')

type(s_layer)
>> arcgis.layers.VoxelLayer

print(s_layer.properties.layers[0].name)
>> 'your layer name'

property manager: SceneLayerManager | EnterpriseSceneLayerManager

The manager property returns an instance of SceneLayerManager class or EnterpriseSceneLayerManager class which provides methods and properties for administering this service.

Bases: Layer

Creates the appropriate Python object for a map service layer or table.

MapServiceLayer is a factory, not a fixed concrete layer type. During construction it reads metadata from a resource URL ending in /MapServer/<layer-or-table-id>. Depending on the resource’s REST type, it returns a MapFeatureLayer, MapRasterLayer, MapTable, or a generic Layer for an unrecognized type such as a group layer.

Map services published by ArcGIS Server can expose dynamic drawing and layer or table queries. Map services hosted by ArcGIS Online or Portal can be cache-only and may not expose those operations. Inspect the service and resource capabilities and advancedQueryCapabilities properties before using an operation. Dynamic layer definitions additionally require the map service’s supportsDynamicLayers property to be True.

Example: Examining properties of MapServiceLayer output

from arcgis.gis import GIS
from arcgis.layers import MapServiceLayer

map_service_lyr_url = 'https://example.dn.com/server/rest/services/<folder>/<svc_name>/MapServer/0'

map_flyr = MapServiceLayer(url=map_service_lyr_url, gis=gis)

map_flyr.properties.advancedQueryCapabilities

Output:

{

“supportsStatistics”: true, “supportsSqlExpression”: true, “supportsQueryWithResultType”: true, “supportsTrueCurve”: true, “supportsOrderBy”: true, “supportsQueryRelatedPagination”: true, “supportsSqlFormat”: false, “useStandardizedQueries”: true, “supportsLod”: false, “supportsQueryWithDistance”: true, “supportsQueryWithCacheHint”: false, “supportsQueryWithDatumTransformation”: true, “supportsCountDistinct”: true, “supportsCurrentUserQueries”: true, “supportsAdvancedQueryRelated”: true, “supportsReturningQueryExtent”: true, “supportsQueryWithLodSR”: false, “supportsPagination”: true, “supportsMaxRecordCountFactor”: false, “supportsDistinct”: true, “supportsTimeRelation”: true, “supportsQueryAnalytic”: false, “supportsPercentileStatistics”: true, “supportsHavingClause”: true

}

Returns:

A MapFeatureLayer, MapRasterLayer, MapTable, or Layer, according to the resource metadata.

Example:

from arcgis.layers import MapFeatureLayer, MapServiceLayer

layer = MapServiceLayer(
    "https://sampleserver6.arcgisonline.com/arcgis/rest/services/"
    "Census/MapServer/3"
)
isinstance(layer, MapFeatureLayer)

Output:

True

Bases: Layer

Represents a feature sublayer in a map service.

A MapFeatureLayer provides access to the features and operations of a sublayer in a MapImageLayer. Instances can be created from a layer URL or obtained from the layers property of a MapImageLayer.

attachements

Deprecated since version 2.4.1: Use the attachments property instead.

Deprecated since version 2.4.1: Use the attachments property instead.

property attachments: AttachmentManager | None

Provides access to the attachments associated with the layer’s features.

Returns:

An AttachmentManager when the layer supports querying attachments; otherwise, None.

property container: MapImageLayer

Returns the map image layer that contains this sublayer.

Returns:

The containing MapImageLayer.

export_attachments(output_folder: str, label_field: str | None = None) → None

Exports layer attachments in an ImageNet-style folder structure.

Attachments are written below an images directory. A mapping.txt file maps each feature object ID to its exported image paths. When label_field is provided, its values are used to group images into subdirectories.

Parameter	Description
output_folder	Required string. An existing folder in which to create the exported attachment structure.
label_field	Optional string. A field whose values identify the category subdirectory for each feature. If not provided, attachments are stored in the default image directory.

Returns:

None

classmethod fromitem(item: Item, layer_id: int = 0) → MapFeatureLayer

Creates a map feature layer from a map service item.

Parameter	Description
item	Required Item. An item whose type is Map Service.
layer_id	Optional integer. The zero-based position of the sublayer in the map service’s layers collection. The default is 0.

Returns:

The selected MapFeatureLayer.

Example:

from arcgis.layers import MapFeatureLayer
from arcgis.gis import GIS

gis = GIS("home")
map_service_item = gis.content.get("<map-service-item-id>")
map_feature_layer = MapFeatureLayer.fromitem(
    item=map_service_item,
    layer_id=2,
)

generate_renderer(definition: dict[str, Any], where: str | None = None) → dict[str, Any]

Generates a renderer from a classification definition.

Use baseSymbol and colorRamp in the definition to control the symbols assigned to each class. An optional SQL where clause limits the features used to generate the renderer.

Note

When the operation is performed on a table, the result contains data classes without symbols.

Parameter	Description
definition	Required dictionary. A class breaks or unique value classification definition used to generate the renderer. See Generate Renderer.
where	Optional string. A where clause for which the data needs to be classified. Any legal SQL where clause operating on the fields in the dynamic layer/table is allowed.

Returns:

A dictionary containing the generated renderer definition.

get_html_popup(oid: str) → dict | str

Returns the HTML pop-up authored for a feature.

Parameter	Description
oid	Required string. The object ID of the feature whose pop-up will be returned.

Returns:

A dictionary containing the pop-up response. An empty string is returned when HTML pop-ups are not configured for the layer.

get_unique_values(attribute: str, query_string: str = '1=1') → list

Returns the unique values for a field.

Parameter	Description
attribute	Required string. The field to query.
query_string	Optional string. An SQL where clause used to filter features before values are returned. The default is 1=1.

Returns:

A list of unique field values, preserving the service response order.

Example:

from arcgis.layers import MapFeatureLayer
from arcgis.gis import GIS

# connect to your GIS and get the map feature layer item
gis = GIS("home")
map_image_item = gis.content.get("2aaddab96684405880d27f5261125061")

map_feature_layer = MapFeatureLayer.fromitem(item=map_image_item, layer_id=2)

# call get unique values method fo the 'Name' attribute
unique_values = map_feature_layer.get_unique_values(
    attribute="Name",
    query_string="name_2 LIKE '%K%'",
)
isinstance(unique_values, list)

Output:

True

query(where: str = '1=1', text: str | None = None, out_fields: str | list[str] = '*', time_filter: list[int | datetime | None] | str | None = None, geometry_filter: GeometryFilter | None = None, return_geometry: bool = True, return_count_only: bool = False, return_ids_only: bool = False, return_distinct_values: bool = False, return_extent_only: bool = False, group_by_fields_for_statistics: str | None = None, statistic_filter: StatisticFilter | None = None, result_offset: int | None = None, result_record_count: int | None = None, object_ids: str | None = None, distance: int | None = None, units: str | None = None, max_allowable_offset: float | None = None, out_sr: int | None = None, geometry_precision: int | None = None, gdb_version: str | None = None, order_by_fields: list[str] | str | None = None, out_statistics: list[dict[str, Any]] | None = None, return_z: bool = False, return_m: bool = False, multipatch_option=None, quantization_parameters: dict[str, Any] | None = None, return_centroid: bool = False, return_all_records: bool = True, result_type: str | None = None, historic_moment: int | datetime | None = None, sql_format: str | None = None, return_true_curves: bool = False, return_exceeded_limit_features: bool | None = None, as_df: bool = False, datum_transformation: int | dict[str, Any] | None = None, range_values: dict[str, Any] | None = None, parameter_values: dict[str, Any] | None = None, **kwargs) → FeatureSet | int | dict | DataFrame

Queries the map feature layer using an SQL statement and optional spatial, temporal, or statistical filters.

Parameter	Description
where	Optional string. The SQL where clause. The default is 1=1.
text	Optional string. A literal search text. If the layer has a display field associated with it, the server searches for this text in this field.
out_fields	Optional list of field names to return. Field names can be specified as a list or a comma-separated string. The default is “*”, which returns all the fields.
object_ids	Optional string. The object IDs of this layer or table to be queried. The object ID values should be a comma-separated string.
distance	Optional integer. The buffer distance for the input geometries. The distance unit is specified by units. For example, if the distance is 100, the query geometry is a point, units is set to meters, and all points within 100 meters of the point are returned.
units	Optional string. The unit for calculating the buffer distance. If unit is not specified, the unit is derived from the geometry spatial reference. If the geometry spatial reference is not specified, the unit is derived from the feature service data spatial reference. This parameter only applies if supportsQueryWithDistance is true. Value options: esriSRUnit_Meter | esriSRUnit_StatuteMile | esriSRUnit_Foot | esriSRUnit_Kilometer | esriSRUnit_NauticalMile | esriSRUnit_USNauticalMile
time_filter	Optional list containing start and end times as datetime.datetime objects or Unix epoch values in milliseconds. Use None for an open start or end. from datetime import datetime time_filter = [datetime(2024, 1, 1), None]
geometry_filter	Optional filter object. Allows for the information to be filtered on spatial relationship with another geometry.
max_allowable_offset	Optional float. This option can be used to specify the max_allowable_offset to be used for generalizing geometries returned by the query operation in the units of out_sr. If out_sr is not specified, the value is in units of the spatial reference of the layer.
out_sr	Optional Integer. The WKID for the spatial reference of the returned geometry.
geometry_precision	Optional Integer. This option can be used to specify the number of decimal places in the response geometries returned by the query operation. This applies to X and Y values only (not m or z-values).
gdb_version	Optional string. The geodatabase version to query. This parameter applies only if the isDataVersioned property of the layer is true. If not specified, the query will apply to the published map’s version.
return_geometry	Optional boolean. If true, geometry is returned with the query. Default is true.
return_distinct_values	Optional boolean. If True, it returns distinct values based on fields specified in out_fields. This parameter applies only if the supportsAdvancedQueries property of the layer is true.
return_ids_only	Optional boolean. Default is False. If True, the response only includes an array of object IDs. Otherwise, the response is a FeatureSet.
return_count_only	Optional boolean. If True, the response only includes the count of features/records satisfying the query. Otherwise, the response is a FeatureSet. The default is False. This option supersedes the return_ids_only parameter. If return_count_only=True, the response returns both the count and the extent.
return_extent_only	Optional boolean. If True, the response only includes the extent of the features satisfying the query. If returnCountOnly=true, the response will return both the count and the extent. The default is False. This parameter applies only if the supportsReturningQueryExtent property of the layer is true.
order_by_fields	Optional string or list of strings. One or more field names by which to order the results. Use ASC or DESC for ascending or descending, respectively, following every field to be ordered: order_by_fields = "STATE_NAME ASC, RACE DESC, GENDER ASC"
group_by_fields_for_statistics	Optional string. One or more field names on which to group results for calculating the statistics. group_by_fields_for_statistics = "STATE_NAME, GENDER"
out_statistics	Optional List. The definitions for one or more field-based statistics to be calculated. Syntax: out_statistics = [ { "statisticType": "count", "onStatisticField": "Field1", "outStatisticFieldName": "Field1_Count", }, { "statisticType": "avg", "onStatisticField": "Field2", "outStatisticFieldName": "Field2_Average", }, ]
return_z	Optional boolean. If True, Z values are included in the results if the features have Z values. Otherwise, Z values are not returned. The default is False.
return_m	Optional boolean. If True, M values are included in the results if the features have M values. Otherwise, M values are not returned. The default is False.
multipatch_option	Optional x/y footprint. This option dictates how the geometry of a multipatch feature will be returned.
result_offset	Optional integer. This option can be used for fetching query results by skipping the specified number of records and starting from the next record (that is, resultOffset + ith value). This option is ignored if return_all_records is True (i.e. by default). This parameter cannot be specified if the service does not support pagination.
result_record_count	Optional integer. This option can be used for fetching query results up to the result_record_count specified. When result_offset is specified but this parameter is not, the map service defaults it to max_record_count. The maximum value for this parameter is the value of the layer’s maxRecordCount property. This option is ignored if return_all_records is True (i.e. by default). This parameter cannot be specified if the service does not support pagination.
quantization_parameters	Optional dict. Used to project the geometry onto a virtual grid, likely representing pixels on the screen.
return_centroid	Optional boolean. Used to return the geometry centroid associated with each feature returned. If True, the result includes the geometry centroid. The default is False.
return_all_records	Optional boolean. When True, the query operation will call the service until all records that satisfy the where_clause are returned. Note result_offset and result_record_count will be ignored if set to True. If return_count_only, return_ids_only, or return_extent_only are True, this parameter is ignored.
result_type	Optional string. Controls the number of features returned by the operation. Options: None | standard | tile Note See Query (Feature Service/Layer) for full explanation.
historic_moment	Optional integer. The historic moment to query. This parameter applies only if the layer is archiving enabled and the supportsQueryWithHistoricMoment property is set to true. This property is provided in the layer’s properties resource. If not specified, the query will apply to the current features.
sql_format	Optional string. The sql_format parameter can be either standard SQL92 or it can use the native SQL of the underlying datastore. The default is None, which means it depends on the useStandardizedQuery layer property. Values: None | standard | native
return_true_curves	Optional boolean. When set to True, returns true curves in output geometries. When set to False, curves are converted to densified polylines or polygons.
return_exceeded_limit_features	Optional boolean. Optional parameter which is true by default. When set to true, features are returned even when the results include the exceededTransferLimit: True property. When set to False and querying with resultType = tile, features are not returned when the results include exceededTransferLimit: True. This allows a client to find the resolution in which the transfer limit is no longer exceeded without making multiple calls.
as_df	Optional boolean. If True, the results are returned as a DataFrame instead of a FeatureSet.
datum_transformation	Optional Integer/Dictionary. This parameter applies a datum transformation while projecting geometries in the results when out_sr is different than the layer’s spatial reference. When specifying transformations, you need to think about which datum transformation best projects the layer (not the feature service) to the outSR and sourceSpatialReference property in the layer properties. For a list of valid datum transformation ID values ad well-known text strings, see Coordinate systems and transformations. For more information on datum transformations, please see the transformation parameter in the Project operation. Example: Inputs Description WKID Integer. datum_transformation = 4326 WKT Dict. datum_transformation = {"wkt": "<WKT>"} Composite Dict. datum_transformation = { "geoTransforms": [ {"wkid": 108190, "forward": True}, {"wkt": "<WKT>", "forward": False}, ] }
range_values	Optional List. Allows you to filter features from the layer that are within the specified range instant or extent. range_values = [ {"name": "elevation", "value": [1000, 1500]}, {"name": "temperature", "value": 20}, ] Note None is allowed in value-range case to indicate infinity # all features with values <= 1500 range_values = [ {"name": "elevation", "value": [None, 1500]} ] # all features with values >= 1000 range_values = [ {"name": "elevation", "value": [1000, None]} ]
parameter_values	Optional Dict. Allows you to filter the layers by specifying value(s) to an array of pre-authored parameterized filters for those layers. When value is not specified for any parameter in a request, the default value, that is assigned during authoring time, gets used instead. When a parameterInfo allows multiple values, you must pass them in an array. Note Check parameterValues at the Query (Map Service/Layer) for details on parameterized filters.
kwargs	Optional dictionary. Additional ArcGIS REST API query parameters, specified using REST parameter names such as cacheHint. Explicit named arguments take precedence when the same REST parameter is supplied in both places. See Query (Map Service/Layer).

Returns:

A FeatureSet containing matching features. Depending on the options, the result can instead be an integer count, a dictionary, or a pandas DataFrame.

Example:

from arcgis.layers import MapImageLayer, MapFeatureLayer
from arcgis.gis import GIS

# connect to your GIS and get the web map item
gis = GIS(url, username, password)

map_image_item = gis.content.get("2aaddab96684405880d27f5261125061")
map_feature_layer = MapFeatureLayer.fromitem(item = map_image_item,
                                                 layer_id = 2)
query_count = map_feature_layer.query(
    where="STATUS = 'Open'",
    return_count_only=True,
)
query_count

Output:

149

query_related_records(object_ids: str, relationship_id: str, out_fields: str | list[str] = '*', definition_expression: str | None = None, return_geometry: bool = True, max_allowable_offset: float | None = None, geometry_precision: int | None = None, out_wkid: int | None = None, gdb_version: str | None = None, return_z: bool = False, return_m: bool = False, historic_moment: int | datetime | None = None, return_true_curve: bool = False) → dict

Queries records related to features in this layer.

The result contains feature sets grouped by source layer/table object IDs. Each FeatureSet contains Feature objects including the values for the fields requested by the user.

Note

For related layers, if you request geometry information, the geometry of each feature is also returned in the feature set. For related tables, the feature set does not include geometries.

Note

See query() for more information about querying a map feature layer.

Parameter	Description
object_ids	Required string. The object IDs of the table/layer to be queried
relationship_id	Required string. The ID of the relationship to be queried.
out_fields	Optional string or list of strings. The fields from the related table/layer to be included in the returned feature set. This list is a comma delimited list of field names. If you specify the shape field in the list of return fields, it is ignored. To request geometry, set return_geometry to true. You can also specify the wildcard “*” as the value of this parameter. In this case, the results will include all the field values.
definition_expression	Optional string. The definition expression to be applied to the related table/layer. From the list of objectIds, only those records that conform to this expression are queried for related records.
return_geometry	Optional boolean. If true, the feature set includes the geometry associated with each feature. The default is true.
max_allowable_offset	Optional float. This option can be used to specify the max_allowable_offset to be used for generalizing geometries returned by the query operation. The max_allowable_offset is in the units of the outSR. If out_wkid is not specified, then max_allowable_offset is assumed to be in the unit of the spatial reference of the map.
geometry_precision	Optional integer. This option can be used to specify the number of decimal places in the response geometries.
out_wkid	Optional Integer. The spatial reference of the returned geometry.
gdb_version	Optional string. The geodatabase version to query. This parameter applies only if the isDataVersioned property of the layer queried is true.
return_z	Optional boolean. If true, Z values are included in the results if the features have Z values. Otherwise, Z values are not returned. The default is false.
return_m	Optional boolean. If true, M values are included in the results if the features have M values. Otherwise, M values are not returned. The default is false.
historic_moment	Optional integer or datetime.datetime. The historic moment to query. This parameter applies only if the supportsQueryWithHistoricMoment property of the layers being queried is set to true. This setting is provided in the layer resource. If historic_moment is not specified, the query will apply to the current features. Syntax: historic_moment=<Epoch time in milliseconds>
return_true_curve	Optional boolean. The default is False. When set to true, returns true curves in output geometries; otherwise, curves are converted to densified polylines or polygons.

Returns:

A dictionary containing related record groups keyed by source object ID.

property renderer: dict | None

Gets or sets the renderer used to display the layer.

Note

Setting this property overrides the layer’s default symbology when it is displayed in a Map.

Returns:

A dictionary containing the renderer definition, or None.

property time_filter: str | None

Gets or sets the time filter applied to the layer.

The filter can be a datetime.datetime, a string containing a Unix epoch value in milliseconds, or a two-value list or tuple that defines a start and end time. Use None for an open start or end. The stored value is a comma-separated string when an extent is set.

Example:

from datetime import datetime, timezone

map_feature_layer.time_filter = [
    datetime(2021, 1, 1, tzinfo=timezone.utc),
    datetime(2022, 1, 10, tzinfo=timezone.utc),
]
map_feature_layer.time_filter

Output:

'1609459200000,1641772800000'

Returns:

A string containing a time instant or comma-separated time extent, or None when no filter is set.

Bases: MapFeatureLayer

Represents a raster sublayer in a map service.

A MapRasterLayer provides access to a raster layer published as part of a MapImageLayer. It represents a Raster Layer resource below a MapServer endpoint; it does not represent a standalone image service. Use ImageryLayer for an ImageServer resource.

Instances are normally returned by MapServiceLayer or from the layers collection of a MapImageLayer. Operations inherited from MapFeatureLayer are available only when supported by the containing map service and advertised by the layer’s properties.

Bases: Layer

Represents an ArcGIS map service and its layers and tables.

A MapImageLayer can export maps, identify and find features, retrieve legends and service information, create dynamic layers, generate KML, and export cached tiles when those capabilities are advertised by the service. Runtime service metadata determines which operations and parameters are available because support varies by ArcGIS Online and Enterprise release.

Example:

from arcgis.gis import GIS
from arcgis.layers import MapImageLayer

gis = GIS()
layer = MapImageLayer(
    "https://sampleserver6.arcgisonline.com/arcgis/rest/services/"
    "Census/MapServer",
    gis,
)
layer.legend

create_dynamic_layer(layer: dict[str, Any]) → FeatureLayer | None

The create_dynamic_layer method creates a dynamic layer. A dynamic layer / table represents a single layer / table of a map service published by ArcGIS Server or of a registered workspace. This resource is supported only when the map image layer supports dynamic layers, as indicated by supportsDynamicLayers on the map image layer properties.

Parameter

Description

layer

Required dict. Dynamic layer/table source definition. Syntax: { “id”: <layerOrTableId>, “source”: <layer source>, //required “definitionExpression”: “<definitionExpression>”, “drawingInfo”: { “renderer”: <renderer>, “transparency”: <transparency>, “scaleSymbols”: <true,false>, “showLabels”: <true,false>, “labelingInfo”: <labeling info> }, “layerTimeOptions”: //supported only for time enabled map layers { “useTime” : <true,false>, “timeDataCumulative” : <true,false>, “timeOffset” : <timeOffset>, “timeOffsetUnits” : “<esriTimeUnitsCenturies,esriTimeUnitsDays, esriTimeUnitsDecades,esriTimeUnitsHours, esriTimeUnitsMilliseconds,esriTimeUnitsMinutes, esriTimeUnitsMonths,esriTimeUnitsSeconds, esriTimeUnitsWeeks,esriTimeUnitsYears | esriTimeUnitsUnknown>” } }

Returns:

FeatureLayer or None (if not enabled)

# USAGE EXAMPLE

>>> from arcgis.layers import MapImageLayer
>>> from arcgis.gis import GIS

# connect to your GIS and get the web map item
>>> gis = GIS(url, username, password)

>>> map_image_item = gis.content.get("2aaddab96684405880d27f5261125061")
>>> layer_to_add ={
                    "id": <layerId>,
                    "source": <layer source>
                    "definitionExpression": "<definitionExpression>",
                    "drawingInfo":
                    {
                      "renderer": <renderer>,
                      "transparency": <transparency>,
                      "scaleSymbols": <true>,
                      "showLabels": <true>,
                      "labelingInfo": <labeling info>
                    },
                    "layerTimeOptions":
                    {
                      "useTime" : <true,false>,
                      "timeDataCumulative" : <true>,
                      "timeOffset" : <timeOffset>,
                      "timeOffsetUnits" : "<esriTimeUnitsCenturies>"
                    }
                  }
>>> new_layer = map_image_item.create_dynamic_layer(layer= layer_to_add)
>>>type(new_layer)
<arcgis.features.FeatureLayer>

estimate_export_tiles_size(export_by: str, levels: str, tile_package: bool = False, export_extent: str = 'DEFAULT', area_of_interest: dict[str, Any] | Polygon | None = None, asynchronous: bool = True, **kwargs) → dict

The estimate_export_tiles_size method is an asynchronous task that allows estimation of the size of the tile package or the cache data set that you download using the export_tiles operation. This operation can also be used to estimate the tile count in a tile package and determine if it will exceed the maxExportTileCount limit set by the administrator of the service. The result of this operation is MapServiceJob. This job response contains reference to Map Service Result resource that returns the total size of the cache to be exported (in bytes) and the number of tiles that will be exported.

Parameter	Description
export_by	Required string. The criteria that will be used to select the tile service levels to export. The values can be Level IDs, cache scales or the Resolution (in the case of image services). Values: “levelId” | “resolution” | “scale”
levels	Required string. Specify the tiled service levels for which you want to get the estimates. The values should correspond to Level IDs, cache scales or the Resolution as specified in export_by parameter. The values can be comma separated values or a range. Example 1: 1,2,3,4,5,6,7,8,9 Example 2: 1-4,7-9
tile_package	Optional boolean. Allows estimating the size for either a tile package or a cache raster data set. Specify the value true for tile packages format and false for Cache Raster data set. The default value is False
export_extent	The extent (bounding box) of the tile package or the cache dataset to be exported. If extent does not include a spatial reference, the extent values are assumed to be in the spatial reference of the map. The default value is full extent of the tiled map service. Syntax: <xmin>, <ymin>, <xmax>, <ymax> Example: -104,35.6,-94.32,41
area_of_interest	Optional dictionary or Polygon. This allows exporting tiles within the specified polygon areas. This parameter supersedes extent parameter. Example: { “features”: [{“geometry”:{“rings”:[[[-100,35], [-100,45],[-90,45],[-90,35],[-100,35]]], “spatialReference”:{“wkid”:4326}}}]}
asynchronous	Optional boolean. The estimate function is run asynchronously requiring the tool status to be checked manually to force it to run synchronously the tool will check the status until the estimation completes. The default is True, which means the status of the job and results need to be checked manually. If the value is set to False, the function will wait until the task completes.

Returns:

dictionary

export_map(bbox: str, bbox_sr: int | dict[str, Any] | _geometry.SpatialReference | None = None, size: str = '600,550', dpi: int = 200, image_sr: int | dict[str, Any] | _geometry.SpatialReference | None = None, image_format: str = 'png', layer_defs: dict[str, Any] | None = None, layers: str | None = None, transparent: bool = False, time_value: list[int] | list[_dt.datetime._dt.datetime] | None = None, time_options: dict[str, Any] | None = None, dynamic_layers: dict[str, Any] | None = None, gdb_version: str | None = None, scale: float | None = None, rotation: float | None = None, transformation: list[int] | list[dict[str, Any]] | None = None, map_range_values: list[dict[str, Any]] | None = None, layer_range_values: list[dict[str, Any]] | None = None, layer_parameter: list[dict[str, Any]] | None = None, historic_moment: int | None = None, clipping: dict[str, Any] | None = None, spatial_filter: dict[str, Any] | None = None, time_relation: str | None = None, selection_definitions: list[dict[str, Any]] | None = None, f: str = 'json', save_folder: str | None = None, save_file: str | None = None, **kwargs) → str

The export_map operation is performed on a map service resource. The result of this operation is a map image resource. This resource provides information about the exported map image such as its URL, its width and height, extent and scale.

Parameter	Description
bbox	Required string. The extent (bounding box) of the exported image. Unless the bbox_sr parameter has been specified, the bbox is assumed to be in the spatial reference of the map.
bbox_sr	Optional integer, SpatialReference. The spatial reference of the bbox.
size	Optional string. size - size of image in pixels
dpi	Optional integer. dots per inch
image_sr	Optional integer, SpatialReference. The spatial reference of the output image.
image_format	Optional string. The format of the exported image. The default format is .png. Values: png | png8 | png24 | jpg | pdf | bmp | gif | svg | svgz | emf | ps | png32
layer_defs	Optional dict. Allows you to filter the features of individual layers in the exported map by specifying definition expressions for those layers. Definition expression for a layer that is published with the service will be always honored.
layers	Optional string. Determines which layers appear on the exported map. There are four ways to specify which layers are shown: show: Only the layers specified in this list will be exported. hide: All layers except those specified in this list will be exported. include: In addition to the layers exported by default, the layers specified in this list will be exported. exclude: The layers exported by default excluding those specified in this list will be exported.
transparent	Optional boolean. If true, the image will be exported with the background color of the map set as its transparent color. The default is false. Note Only the .png and .gif formats support transparency.
time_value	Optional list. The time instant or the time extent of the features to be identified.
time_options	Optional dict. The time options per layer. Users can indicate whether or not the layer should use the time extent specified by the time parameter or not, whether to draw the layer features cumulatively or not and the time offsets for the layer.
dynamic_layers	Optional dict. Use dynamicLayers property to reorder layers and change the layer data source. dynamicLayers can also be used to add new layer that was not defined in the map used to create the map service. The new layer should have its source pointing to one of the registered workspaces that was defined at the time the map service was created. The order of dynamicLayers array defines the layer drawing order. The first element of the dynamicLayers is stacked on top of all other layers. When defining a dynamic layer, source is required.
gdb_version	Optional string. Switch map layers to point to an alternate geodatabase version.
scale	Optional float. Use this parameter to export a map image at a specific map scale, with the map centered around the center of the specified bounding box (bbox)
rotation	Optional float. Use this parameter to export a map image rotated at a specific angle, with the map centered around the center of the specified bounding box (bbox). It could be positive or negative number.
transformations	Optional list. Use this parameter to apply one or more datum transformations to the map when sr is different than the map service’s spatial reference. It is an array of transformation elements.
map_range_values	Optional list. Allows you to filter features in the exported map from all layer that are within the specified range instant or extent.
layer_range_values	Optional dictionary. Allows you to filter features for each individual layer that are within the specified range instant or extent. Note: Check range infos at the layer resources for the available ranges.
layer_parameter	Optional list. Allows you to filter the features of individual layers in the exported map by specifying value(s) to an array of pre-authored parameterized filters for those layers. When value is not specified for any parameter in a request, the default value, that is assigned during authoring time, gets used instead.

Returns:

A string, image of the map.

# USAGE EXAMPLE

>>> from arcgis.layers import MapImageLayer
>>> from arcgis.gis import GIS

# connect to your GIS and get the web map item
>>> gis = GIS(url, username, password)

>>> map_image_item = gis.content.get("2aaddab96684405880d27f5261125061")
>>> map_image_item.export_map(bbox="-104,35.6,-94.32,41",
                              bbox_sr = 4326,
                              image_format ="png",
                              layers = "include",
                              transparent = True,
                              scale = 40.0,
                              rotation = -45.0
                              )

export_tiles(levels: str, export_by: str = 'LevelID', tile_package: bool = True, export_extent: dict[str, Any] | str | None = None, optimize_for_size: bool = True, compression: int = 75, area_of_interest: dict[str, Any] | Polygon | None = None, asynchronous: bool = False, storage_format: str | None = None, **kwargs) → str | dict

The export_Tiles operation is performed as an asynchronous task and allows client applications to download map tiles from a server for offline use. This operation is performed on a Map Service that allows clients to export cache tiles. The result of this operation is a Map Service Job. This job response contains a reference to the Map Service Result resource, which returns a URL to the resulting tile package (.tpk) or a cache raster dataset. export_Tiles can be enabled in a service by using ArcGIS Desktop or the ArcGIS Server Administrator Directory. In ArcGIS Desktop make an admin or publisher connection to the server, go to service properties, and enable Allow Clients to Export Cache Tiles in the advanced caching page of the Service Editor. You can also specify the maximum tiles clients will be allowed to download.

Note

The default maximum allowed tile count is 100,000. To enable this capability using the Administrator Directory, edit the service, and set the properties exportTilesAllowed = True and maxExportTilesCount = 100000.

Note

In ArcGIS Server 10.2.2 and later versions, exportTiles is supported as an operation of the Map Server. The use of the http://Map_Service/exportTiles/submitJob operation is deprecated. You can provide arguments to the exportTiles operation as defined in the following parameters table:

Parameter	Description
levels	Required string. Specifies the tiled service levels to export. The values should correspond to Level IDs, cache scales. or the resolution as specified in export_by parameter. The values can be comma separated values or a range. Make sure tiles are present at the levels where you attempt to export tiles. Example 1: 1,2,3,4,5,6,7,8,9 Example 2: 1-4,7-9
export_by	Required string. The criteria that will be used to select the tile service levels to export. The values can be Level IDs, cache scales. or the resolution. The default is ‘LevelID’. Values: levelId | resolution | scale
tile_package	Optional boolean. Allows exporting either a tile package or a cache raster data set. If the value is true, output will be in tile package format, and if the value is false, a cache raster data set is returned. The default value is True.
export_extent	Optional dictionary or string. The extent (bounding box) of the tile package or the cache dataset to be exported. If extent does not include a spatial reference, the extent values are assumed to be in the spatial reference of the map. The default value is full extent of the tiled map service. Syntax: <xmin>, <ymin>, <xmax>, <ymax> Example 1: -104,35.6,-94.32,41 Example 2: {“xmin” : -109.55, “ymin” : 25.76, “xmax” : -86.39, “ymax” : 49.94, “spatialReference” : {“wkid” : 4326}}
optimize_for_size	Optional boolean. Use this parameter to enable compression of JPEG tiles and reduce the size of the downloaded tile package or the cache raster data set. Compressing tiles slightly compromises the quality of tiles but helps reduce the size of the download. Try sample compressions to determine the optimal compression before using this feature. The default value is True.
compression=75,	Optional integer. When optimize_for_size=true, you can specify a compression factor. The value must be between 0 and 100. The value cannot be greater than the default compression already set on the original tile. For example, if the default value is 75, the value of compressionQuality must be between 0 and 75. A value greater than 75 in this example will attempt to up sample an already compressed tile and will further degrade the quality of tiles.
area_of_interest	Optional dictionary, Polygon. The area_of_interest polygon allows exporting tiles within the specified polygon areas. This parameter supersedes the exportExtent parameter. Example: { “features”: [{“geometry”:{“rings”:[[[-100,35], [-100,45],[-90,45],[-90,35],[-100,35]]], “spatialReference”:{“wkid”:4326}}}]}
asynchronous	Optional boolean. Default False, this value ensures the returns are returned to the user instead of the user having the check the job status manually.
storage_format	Optional string. Specifies the type of tile package that will be created. tpk - Tiles are stored using Compact storage format. It is supported across the ArcGIS platform. tpkx - Tiles are stored using CompactV2 storage format, which provides better performance on network shares and cloud store directories. This improved and simplified package structure type is supported by newer versions of ArcGIS products such as ArcGIS Online 7.1, ArcGIS Enterprise 10.7, and ArcGIS Runtime 100.5. This is the default.

Returns:

A path to download file is asynchronous is False. If True, a dictionary is returned.

find(search_text: str, layers: str, contains: bool = True, search_fields: str | None = None, sr: dict[str, Any] | str | SpatialReference | None = None, layer_defs: dict[str, Any] | None = None, return_geometry: bool = True, max_offset: int | None = None, precision: int | None = None, dynamic_layers: dict[str, Any] | None = None, return_z: bool = False, return_m: bool = False, gdb_version: str | None = None, return_unformatted: bool = False, return_field_name: bool = False, transformations: list[int] | list[dict[str, Any]] | None = None, map_range_values: list[dict[str, Any]] | None = None, layer_range_values: dict[str, Any] | None = None, layer_parameters: list[dict[str, Any]] | None = None, **kwargs) → dict

The find method performs the map service find operation.

Parameter	Description
search_text	Required string.The search string. This is the text that is searched across the layers and fields the user specifies.
layers	Optional string. The layers to perform the identify operation on. There are three ways to specify which layers to identify on: top: Only the top-most layer at the specified location. visible: All visible layers at the specified location. all: All layers at the specified location.
contains	Optional boolean. If false, the operation searches for an exact match of the search_text string. An exact match is case sensitive. Otherwise, it searches for a value that contains the search_text provided. This search is not case sensitive. The default is true.
search_fields	Optional string. List of field names to look in.
sr	Optional dict, string, or SpatialReference. The well-known ID of the spatial reference of the input and output geometries as well as the map_extent. If sr is not specified, the geometry and the map_extent are assumed to be in the spatial reference of the map, and the output geometries are also in the spatial reference of the map.
layer_defs	Optional dict. Allows you to filter the features of individual layers in the exported map by specifying definition expressions for those layers. Definition expression for a layer that is published with the service will be always honored.
return_geometry	Optional boolean. If true, the result set will include the geometries associated with each result. The default is true.
max_offset	Optional integer. This option can be used to specify the maximum allowable offset to be used for generalizing geometries returned by the identify operation.
precision	Optional integer. This option can be used to specify the number of decimal places in the response geometries returned by the identify operation. This applies to X and Y values only (not m or z-values).
dynamic_layers	Optional dict. Use dynamicLayers property to reorder layers and change the layer data source. dynamicLayers can also be used to add new layer that was not defined in the map used to create the map service. The new layer should have its source pointing to one of the registered workspaces that was defined at the time the map service was created. The order of dynamicLayers array defines the layer drawing order. The first element of the dynamicLayers is stacked on top of all other layers. When defining a dynamic layer, source is required.
return_z	Optional boolean. If true, Z values will be included in the results if the features have Z values. Otherwise, Z values are not returned. The default is false.
return_m	Optional boolean.If true, M values will be included in the results if the features have M values. Otherwise, M values are not returned. The default is false.
gdb_version	Optional string. Switch map layers to point to an alternate geodatabase version.
return_unformatted	Optional boolean. If true, the values in the result will not be formatted i.e. numbers will be returned as is and dates will be returned as epoch values.
return_field_name	Optional boolean. If true, field names will be returned instead of field aliases.
transformations	Optional list. Use this parameter to apply one or more datum transformations to the map when sr is different from the map service’s spatial reference. It is an array of transformation elements.
map_range_values	Optional list. Allows you to filter features in the exported map from all layer that are within the specified range instant or extent.
layer_range_values	Optional dictionary. Allows you to filter features for each individual layer that are within the specified range instant or extent. Note: Check range infos at the layer resources for the available ranges.
layer_parameters	Optional list. Allows you to filter the features of individual layers in the exported map by specifying value(s) to an array of pre-authored parameterized filters for those layers. When value is not specified for any parameter in a request, the default value, that is assigned during authoring time, gets used instead.

Returns:

A dictionary

# USAGE EXAMPLE

>>> from arcgis.layers import MapImageLayer
>>> from arcgis.gis import GIS

# connect to your GIS and get the web map item
>>> gis = GIS(url, username, password)

>>> map_image_item = gis.content.get("2aaddab96684405880d27f5261125061")
>>> search_results = map_image_item.find(search_text = "Hurricane Data",
                        contains = True,
                        layers = "top",
                        return_geometry = False,
                        max_offset = 100,
                        return_z = True,
                        return_m = False,
                        )
>>> type(search_results)
<Dictionary>