arcgis.map module | ArcGIS API for Python

Map

class arcgis.map.Map(**kwargs: Any)

Class that can be used to visualize content in a Jupyter Lab notebook and/or used to create and save web map items.

Note

A Map object can be managed through Python scripts, but is only able to be visualized within a Jupyter Lab or ArcGIS notebooks environment.

Parameter	Description
location	Optional string. The address or place to center the `map widget`.
item	Optional Web Map `Item`. If provided will be used to initialize a map widget object.
gis	Optional `GIS`. The GIS instance to use for working with the map. If no argument is provided, the current active GIS will be used. Note Particularly important to use in notebooks with multiple GIS instances.

Returns:: A map widget instance.

# Usage Example 1: Initializing map with existing web map
from arcgis.gis import GIS
from arcgis.map import Map

gis = GIS(profile="your_organization_profile")

wm_item = gis.content.get("<item_id>")

new_map = Map(item=wm_item)

property basemap: BasemapManager: Returns a BasemapManager object that can be used to handle basemap related properties and methods on the Map.

property bookmarks: Bookmarks: Get an instance of the Bookmarks that can be seen in your Map. This class can be used to add and remove bookmarks as well as edit them. You can also enable and disable the bookmark widget on the rendered map in Jupyter Lab.

property center

Get/Set the center of the rendered Map.

Parameter	Description
center	A [lat, long] list that represents the JSON of the map widget’s center.

Returns:: A list that represents the latitude and longitude of the map’s center.

# Usage example: Sets the center of the map to the given lat/long
map.center = [34.05, -118.24]

property content: MapContent: Returns a MapContent object that can be used to access the layers and tables in the map. This is useful for adding, updating, getting, and removing content from the Map.

export_to_html(path_to_file: str, title: str | None = None) → bool

The export_to_html method takes the current state of the rendered map and exports it to a standalone HTML file that can be viewed in any web browser.

By default, only publicly viewable layers will be visible in any exported html map. Specify credentials_prompt=True to have a user be prompted for their credentials when opening the HTML page to view private content.

Warning

Follow best security practices when sharing any HTML page that prompts a user for a password.

Note

You cannot successfully authenticate if you open the HTML page in a browser locally like file://path/to/file.html. The credentials prompt will only properly function if served over a HTTP/HTTPS server.

Parameter	Description
path_to_file	Required string. The path to save the HTML file on disk.
title	Optional string. The HTML title tag used for the HTML file.

property extent

Get/Set the map’s extent.

Parameter	Description
extent	A dictionary that represents the JSON of the map widget’s extent.

Returns:: A dictionary representing the map’s extent.

# Usage example: Sets the extent of the map to the given extent
map.extent = {
    "xmin": -124.35,
    "ymin": 32.54,
    "xmax": -114.31,
    "ymax": 41.95
    "spatialReference": { "wkid":102100 }
}

js_api_path: A trait for unicode strings.

js_requirement()

Return the JS API version needed to work with the current version of the mapping module in a disconnected environment. For more information on how to set up your disconnected environment, see https://developers.arcgis.com/python/latest/guide/install-and-set-up/offline/

Returns:: A dictionary in the format: {“JS_API”: <version_number>}.

property layer_list: LayerList: Get an instance of the LayerList class. You can use this class to enable or disable the layer list widget. Best used inside of Jupyter Lab.

property legend: Legend: Get an instance of the Legend class. You can use this class to enable or disable the legend widget. Best used inside of Jupyter Lab.

property offline_areas: OfflineMapAreaManager | None

The offline_areas property is the resource manager for offline areas cached for the WebMap object.

Returns:: The OfflineMapAreaManager for the WebMap object.

print(file_format: str, extent: dict[str, Any], dpi: int = 92, output_dimensions: tuple[float] = (500, 500), scale: float | None = None, rotation: float | None = None, spatial_reference: dict[str, Any] | None = None, layout_template: str = 'MAP_ONLY', time_extent: tuple[int] | list[int] | None = None, layout_options: dict[str, Any] | None = None) → str

The print method prints the Map object to a printable file such as a PDF, PNG32, JPG.

Note

The render and print operations happen server side (ArcGIS Online or Enterprise) and not on the client.

The print method takes the state of the Map, renders and returns either a page layout or a map without page surrounds of the specified extent in raster or vector format.

Parameter	Description
file_format	Required String. Specifies the output file format. Valid types: `PNG8` \| `PNG32` \| `JPG` \| `GIF` \| `PDF` \| `EPS` \| `SVG` \| `SVGZ`.
extent	Required Dictionary. Specify the extent to be printed. # Example Usage: >>> extent = {'spatialReference': {'latestWkid': 3857, 'wkid': 102100}, 'xmin': -15199645.40582486, 'ymin': 3395607.5273594954, 'xmax': -11354557.134968376, 'ymax': 5352395.451459487} The spatial reference of the extent object is optional; when it is not provided, it is assumed to be in the map’s spatial reference. When the aspect ratio of the map extent is different than the size of the map on the output page or the `output_dimensions`, you might notice more features on the output map.
dpi	Optional integer. Specify the print resolution of the output file. `dpi` stands for dots per inch. A higher number implies better resolution and a larger file size.
output_dimensions	Optional tuple. Specify the dimensions of the output file in pixels. If the `layout_template` is not `MAP_ONLY`, the specific layout template chosen takes precedence over this parameter.
scale	Optional float. Specify the map scale to be printed. The map scale at which you want your map to be printed. This parameter is optional but recommended for optimal results. The `scale` property is especially useful when map services in the web map have scale-dependent layers or reference scales set. Since the map that you are viewing on the web app may be smaller than the size of the output map (for example, 8.5 x 11 in. or A4 size), the scale of the output map will be different and you could see differences in features and/or symbols in the web application as compared with the output map. When scale is used, it takes precedence over the extent, but the output map is drawn at the requested scale centered on the center of the extent.
rotation	Optional float. Specify the number of degrees by which the map frame will be rotated, measured counterclockwise from the north. To rotate clockwise, use a negative value.
spatial_reference	Optional Dictionary.Specify the spatial reference in which map should be printed. When not specified, the following is the order of precedence: read from the `extent` parameter read from the base map layer of your web map read from the `layout_template` chosen
layout_template	Optional String. The default value `MAP_ONLY` does not use any template.
time_extent	Optional List . If there is a time-aware layer and you want it to be drawn at a specified time, specify this property. This order list can have one or two elements. Add two elements (`startTime` followed by `endTime`) to represent a time extent, or provide only one time element to represent a time instant. Times are always in UTC. # Example Usage to represent Tues. Jan 1, 2008 00:00:00 UTC: # to Thurs. Jan 1, 2009 00:00:00 UTC. >>> time_extent = [1199145600000, 1230768000000]
layout_options	Optional Dictionary. This defines settings for different available page layout elements and is only needed when an available `layout_template` is chosen. Page layout elements include `title`, `copyright text`, `scale bar`, `author name`, and `custom text elements`. For more details, see ExportWebMap specification.

Returns:: A URL to the file which can be downloaded and printed.

# USAGE EXAMPLE 1: Printing a web map to a JPG file of desired extent.

from arcgis.map import Map
from arcgis.gis import GIS

# connect to your GIS and get the web map item
gis = GIS(url, username, password)
wm_item = gis.content.get('1234abcd_web map item id')

# create a WebMap object from the existing web map item
wm = Map(item=wm_item)

# create an empty web map
wm2 = Map()
wm2.content.add(<desired Item or Layer object>)

# set extent
redlands_extent = {'spatialReference': {'latestWkid': 3857, 'wkid': 102100},
                     'xmin': -13074746.000753032,
                     'ymin': 4020957.451106308,
                     'xmax': -13014666.49652086,
                     'ymax': 4051532.26242039}

# print
printed_file_url = wm.print(file_format='JPG', extent=redlands_extent)
printed_file2_url = wm2.print(file_format='PNG32', extent=redlands_extent)

# Display the result in a notebook:
from IPython.display import Image
Image(printed_file_url)

# Download file to disk
import requests
with requests.get(printed_file_url) as resp:
    with open('./output_file.png', 'wb') as file_handle:
        file_handle.write(resp.content)

property rotation

Get/Set the rotation of the rendered Map.

Parameter	Description
value	Required int. The rotation angle in degrees.

Returns:: The int value of the rotation angle

# Usage example: Sets the rotation angle of the map to 45 degrees
map.rotate = 45

save(item_properties: dict[str, Any], thumbnail: str | None = None, metadata: str | None = None, owner: str | None = None, folder: str | None = None) → Item

Saves the Map object as a new Web Map Item in your GIS.

Note

If you started with a Map object from an existing web map item, calling this method will create a new item with your changes. If you want to update the existing Map item found in your portal with your changes, call the update method instead.

Parameter	Description
item_properties	Required dictionary. See table below for the keys and values. The three required keys are: ‘title’, ‘tag’, ‘snippet’.
thumbnail	Optional string. Either a path or URL to a thumbnail image.
metadata	Optional string. Either a path or URL to the metadata.
owner	Optional string. Defaults to the logged in user.
folder	Optional string. Name of the folder into which the web map should be saved.

Key:Value Dictionary Options for Argument item_properties

Key	Value
title	Required string. Name label of the item.
tags	Required string. Tags listed as comma-separated values, or a list of strings. Used for searches on items.
snippet	Required string. Provide a short summary (limit to max 250 characters) of the what the item is.
typeKeywords	Optional string. Provide a lists all subtypes, see URL 1 below for valid values.
description	Optional string. Description of the item.
extent	Optional dict. The extent of the item.
accessInformation	Optional string. Information on the source of the content.
licenseInfo	Optional string. Any license information or restrictions regarding the content.
culture	Optional string. Locale, country and language information.
access	Optional string. Valid values are private, shared, org, or public.
commentsEnabled	Optional boolean. Default is true, controls whether comments are allowed (true) or not allowed (false).
culture	Optional string. Language and country information.

The above are the most common item properties (metadata) that you set. To get a complete list, see the Common Parameters page in the ArcGIS REST API documentation.

Returns:

Item object corresponding to the new web map Item created.

# save the web map webmap_item_properties = {‘title’:’Ebola incidents and facilities’,

’snippet’:’Map created using Python API showing locations of Ebola treatment centers’, ‘tags’:[‘automation’, ‘ebola’, ‘world health’, ‘python’], ‘extent’: {‘xmin’: -122.68, ‘ymin’: 45.53, ‘xmax’: -122.45, ‘ymax’: 45.6, ‘spatialReference’: {‘wkid’: 4326}}}

new_wm_item = wm.save(webmap_item_properties, thumbnail=’./webmap_thumbnail.png’)

property scale

Get/Set the map scale at the center of the rendered Map. If set to X, the scale of the map would be 1:X.

Parameter	Description
value	Required int.

Returns:: The int value of the scale

# Usage example: Sets the scale to 1:24000
map.scale = 24000

sync_navigation(map: Map | list[Map]) → None

The sync_navigation method synchronizes the navigation from one rendered Map to another rendered Map instance so panning/zooming/navigating in one will update the other.

Note

Users can sync more than two instances together by passing in a list of Map instances to sync. The syncing will be remembered

Parameter	Description
map	Either a single Map instance, or a list of `Map` instances to synchronize to.

theme

Get/Set the widget theme when displaying in a Jupyter environment.

Values can be “light” or “dark”

property time_slider: TimeSlider: Get an instance of the TimeSlider class. You can use this class to enable or disable the time slider on the widget. Best used inside of Jupyter Lab

unsync_navigation(map: Map | list[Map] | None = None) → None

The unsync_navigation method unsynchronizes connections made to other rendered Map instances made via the sync_navigation method.

Parameter	Description
map	Optional, either a single Map instance, or a list of Map instances to unsynchronize. If not specified, will unsynchronize all synced Map instances.

update(item_properties: dict[str, Any] | None = None, thumbnail: str | None = None, metadata: str | None = None) → bool

The update method updates the Web Map Item in your GIS with the changes you made to the Map object. In addition, you can update other item properties, thumbnail and metadata.

Note

If you started with a Map object from an existing web map item, calling this method will update the item with your changes.

If you started out with a fresh Map object (without a web map item), calling this method will raise a RuntimeError exception. If you want to save the Map object into a new web map item, call the save method instead.

For item_properties, pass in arguments for the properties you want to be updated. All other properties will be untouched. For example, if you want to update only the item’s description, then only provide the description argument in item_properties.

Parameter	Description
item_properties	Optional dictionary. See table below for the keys and values.
thumbnail	Optional string. Either a path or URL to a thumbnail image.
metadata	Optional string. Either a path or URL to the metadata.

Key:Value Dictionary Options for Argument item_properties

Key	Value
typeKeywords	Optional string. Provide a lists all sub-types, see URL 1 below for valid values.
description	Optional string. Description of the item.
title	Optional string. Name label of the item.
tags	Optional string. Tags listed as comma-separated values, or a list of strings. Used for searches on items.
snippet	Optional string. Provide a short summary (limit to max 250 characters) of the what the item is.
accessInformation	Optional string. Information on the source of the content.
licenseInfo	Optional string. Any license information or restrictions regarding the content.
culture	Optional string. Locale, country and language information.
access	Optional string. Valid values are private, shared, org, or public.
commentsEnabled	Optional boolean. Default is true, controls whether comments are allowed (true) or not allowed (false).

The above are the most common item properties (metadata) that you set. To get a complete list, see the common parameters page in the ArcGIS REST API documentation.

Returns:: A boolean indicating success (True) or failure (False).

property zoom

Get/Set the level of zoom applied to the rendered Map.

Parameter	Description
value	Required int. .. note: The higher the number, the more zoomed in you are.

Returns:: Int value that represent the zoom level

# Usage example
map.zoom = 10

The zoom_to_layer method snaps the map to the extent of the provided Item object(s).

Zoom to layer is modifying the rendered map’s extent. It is best to run this method call in a separate cell from the map rendering cell to ensure the map is rendered before the extent is set.

Parameter	Description
item	The item at which you want to zoom your map to. This can be a single extent or an `Item`, `Layer` , `DataFrame` , `FeatureLayer`, `SubtypeGroupLayer`, `FeatureSet`, or `FeatureCollection` object.

Map Classes

Bookmarks

class arcgis.map.map_widget.Bookmarks(map: Map)

The Bookmarks allows end users to quickly navigate to a particular area of interest. This class allows users to add, remove and edit bookmarks in their Map.

Note

This class should now be created by a user but rather called through the bookmarks property on a Map instance.

add(name: str, extent: dict, rotation: int | None = None, time_extent: dict | None = None, index: int | None = None) → bool

Add a new bookmark

Parameter	Definition
name	Required string. The name of the bookmark.
extent	Required dict. The extent of the bookmark.
rotation	Optional float. The rotation of the viewpoint for the bookmark.
time_extent	Optional dict. The time extent of the bookmark item. Example: time_extent = { “start”: datetime.datetime(1996, 11, 10), “end”: datetime.datetime(1996, 11, 25) }
index	Required integer. The index position for the bookmark. If none specified, added to the end of the list.

property enabled: bool: Get and set whether the bookmarks widget is shown on the rendered or not. Set to True for the bookmarks to be visible.

property list: list[Bookmark]

remove(index: int) → bool

Remove a bookmark from the list of bookmarks.

Parameter	Definition
index	Required integer. The index for the bookmark in the bookmarks list that will be removed.

Bookmark

class arcgis.map.map_widget.Bookmark(bookmark: Bookmark, bm_mngr: Bookmarks)

Represent one bookmark in the webmap. This class can be used to edit a bookmark instant and can be accessed through the list property of the Bookmarks class.

Note

This class should now be created by a user but rather called through the list property on a Bookmarks instance.

edit(name: str | None = None, extent: dict | None = None, rotation: int | None = None, time_extent: dict | None = None) → None

Edit the properties of a bookmark. Edit the name, extent, rotation, scale and/or time_extent.

Parameter	Definition
name	Optional string. The name of the bookmark.
extent	Optional dict. The extent of the bookmark.
rotation	Optional float. The rotation of the viewpoint for the bookmark.
time_extent	Optional dict. The time extent of the bookmark item. Example: time_extent = { “start”: datetime.datetime(1996, 11, 10), “end”: datetime.datetime(1996, 11, 25) }

property extent: dict: Returns the extent of the bookmark

property name: str: Returns the name of the bookmark

property viewpoint: dict: Returns the current viewpoint set for the bookmark

MapContent

class arcgis.map.map_widget.MapContent(webmap: Map)

This class allows users to manage the content of a webmap. Users can view the operational layers, add layers, reorder layers, and remove layers.

This class is created from the map_content property on a Map instance.

Add a layer or table to the map.

Note

The spatial reference of the map is derived from the basemap layer. If the spatial reference of the layer being added is different from the map’s spatial reference, you may not see it render correctly. You can set the layer as the basemap to change the map’s spatial reference.

Parameter	Description
item	Required Portal Item, Layer, Spatial DataFrame, or Feature Collection to add to the map. If an item is passed in: Creates a new layer instance of the appropriate layer class from an ArcGIS Online or ArcGIS Enterprise portal item. * If the item points to a feature service with multiple layers, then a GroupLayer is created. * If the item points to a service with a single layer, then it resolves to a layer of the same type of class as the service. * To add an ogc feature service, pass in an instance of the OGCFeatureService class. The first collection of the service will be added. If you want to specify the collection then you can pass in an instance of the FeatureCollection you want added. * A list of layers. This is useful when wanting to create a GroupLayer out of multiple layers. The list can contain any combination of the layer types listed above. * Raster object created from a local raster can be added. However, the raster will only render on the map and cannot be saved to the webmap. The raster will be added as a MediaLayer. Note If the item is a WMTS Layer, you can pass a key-value pair in the options parameter to select which layer to add if the WMTS service has multiple layers. The key should be ‘layer’ and the value should be the layer identifier. If nothing is passed, the first layer will be added.
drawing_info	Optional dictionary representing the drawing info to apply to the layer. The keys can include any combination of: ‘renderer’, ‘labelingInfo’, ‘scaleSymbols’, ‘showLabels’, ‘transparency’. This can only be applied when adding one layer. Renderer ‘type’ can be “simple”, “uniqueValue”, “classBreaks”, “heatmap”, “dotDensity”, etc. To create a renderer see the renderer module where all the dataclasses are defined. Example Structure: drawing_info = { “labelingInfo”: <list>, “renderer”: <Renderer Dataclass>, “scaleSymbols”: <bool>, “showLabels”: <bool>, “transparency”: <float> } More information on the structure of the dictionary can be found in the ArcGIS REST API documentation.
popup_info	Optional PopupInfo dataclass that can be created from the popups module. See: `PopupInfo`
index	Optional integer. Determines at what index the layer should be added.
options	Optional dictionary. Pass in key, value pairs that will edit the layer properties. This is useful for updating the layer properties that are not exposed through the other parameters. For example, you can update the layer title, opacity, or other properties that are applicable for the type of layer. You can pass in the service item id associated to the service url to persist renderer and popup info that is available in the service item. You can pass custom parameters as well by adding a key-value pair to the dictionary. Example: {“custom_parameters”: {“subscription-key”: “your_key”}}

# Usage Example 1: Add a layer from a portal item
m = Map()
item = gis.content.get(<item_id>)

renderer = HeatmapRenderer(**{
        "authoringInfo": {"fadeRatio": 0.2},
        "type": "heatmap",
        "blurRadius": 5.555555555555556,
        "colorStops": [
            {"color": [133, 193, 200, 0], "ratio": 0},
            {"color": [144, 161, 190, 212], "ratio": 0.0925},
            {"color": [156, 129, 132, 255], "ratio": 0.17500000000000002},
            {"color": [167, 97, 170, 255], "ratio": 0.2575},
            {"color": [175, 73, 128, 255], "ratio": 0.34},
            {"color": [255, 255, 0, 255], "ratio": 1},
        ],
        "maxDensity": 0.611069562632112,
        "maxPixelIntensity": 139.70497545315783,
        "minDensity": 0,
        "minPixelIntensity": 0,
        "radius": 10,
})
m.content.add(item, drawing_info={"renderer": renderer})

clear_cache()

draw(shape, popup=None, symbol=None, attributes=None, title: str | None = None) → None

Draw a shape on the map. This will add the shape as a feature collection to your layers of the map. Anything can be drawn from known Geometry objects.

The shape will be drawn as a feature collection on the map. This means that the shape will be added as a layer to the map. The shape will be drawn with the symbol and popup info that is passed in. If no symbol is passed in, a default symbol will be created based on the geometry type. If no popup is passed in, a default popup will be created with the title of the feature collection. The attributes will be added to the feature collection as well.

Note

Ensure that the spatial reference of the shape matches the spatial reference of the map. If the spatial reference does not match, the shape will be added but not drawn on the map. To see the spatial reference of the map, call the extent property on the map.

Parameter	Description
shape	Required Geometry object. Known `Geometry` objects: Shape is one of [‘circle’, ‘ellipse’, `Polygon`, `Polyline`, `MultiPoint`, `Point`, ‘rectangle’, ‘triangle’].
popup	Optional PopupInfo Dataclass. See: `PopupInfo`
symbol	Optional Symbol Dataclass. See the symbols module where all the dataclasses are defined.
attributes	Optional dict. Specify a dict containing name value pairs of fields and field values associated with the graphic.
title	Optional string. The title of the feature collection that will be created from the geometry or feature set.

form(index: int) → FormInfo

Deprecated since version 2.4.3: Removed in: 2.5.0. Use form_manager.form_info instead.

Get an instance of the FormInfo dataclass for the layer specified. Specify the layer through it’s position in the list of layers. The list of layers can be accessed with the layers property.

Through this class you can edit the form properties for your layer.

Layer types that have forms include: Feature Layer, Table, and Oriented Imagery Layer.

Parameter	Description
index	Required index specifying the layer who’s form properties you want to access. To get a full list of layers use the layers property. Note If the layer belongs inside a group layer then use the instance of the Group layer class returned from the layers property to access the layers within the group and to use the forms method in that class.

Returns:: FormInfo dataclass for the layer specified.

To see this dataclass, see the forms module where it is defined. You can also get the dataclass as a dict by calling the dict method on the dataclass.

form_manager(index: int) → FormManager

Get an instance of the FormManager class for the layer specified. Specify the layer through it’s position in the list of layers. The list of layers can be accessed with the layers property. Through this class you can edit the form properties for your layer.

Layer types that have forms include: Feature Layer, Table, and Oriented Imagery Layer.

Parameter	Description
index	Required index specifying the layer who’s form properties you want to access. To get a full list of layers use the layers property. Note If the layer belongs inside a group layer then use the instance of the Group layer class returned from the layers property to access the layers within the group and to use the form_manager method in that class.

Returns:: FormManager class for the layer specified.

get_layer(title: str) → Layer

Get a layer or table from the map by title. If the layer is added more than once only the first instance of the layer will be returned.

..note::: To find a layer by index you can use the layer_info method to see the layers in a table form.

Parameter	Definition
title	Required string. The title of the layer or table to get.

Returns:: Layer

get_table(title: str) → arcgis.gis.Table

Get a table from the map by title. If the table is added more than once only the first instance of the table will be returned.

..note::: To find a table by index you can use the table_info method to see the tables in a table form.

Parameter	Definition
title	Required string. The title of the table to get.

Returns:: Table

property layer_info: DataFrame: Return a DataFrame with information about the layers in the map.

layer_visibility(index: int) → LayerVisibility

Get an instance of the LayerVisibility class for the layer specified. Specify the layer through it’s position in the list of layers. The list of layers can be accessed with the layers property. Through this class you can edit the visibility for your layer on the map and in the legend.

Parameter	Description
index	Required index specifying the layer who’s visibility properties you want to access. To get a full list of layers use the layers property. Note If the layer belongs inside a group layer then use the instance of the Group layer class returned from the layers property to access the layers within the group and to use the layer_visibility method in that class.

Returns:: LayerVisibility class for the layer specified.

layers: list

move(index: int, group: GroupLayer) → None

Move a layer into an existing GroupLayer’s list of layers.

Parameter	Description
index	Required int. The index of the layer you want to move.
group	Required GroupLayer instance. The group layer you want to move the layer to.

move_to_basemap(index: int) → bool

Move a layer to be a basemap layer. A basemap layer is a layer that provides geographic context to the map. A web map always contains a basemap. The following is a list of possible basemap layer types:

Image Service Layer
Image Service Vector Layer
Map Service Layer
Tiled Image Service Layer
Tiled Map Service Layer
Vector Tile Layer
WMS Layer

Parameter	Definition
index	Required integer. The index of the layer from operational layers that will be moved to basemap layers. The list of available layers is found when calling the layers property on the Map.

# Create a Map from an existing Map Item.
wm = Map(item=<webmap_item_id>)
# Get and add the layer to the map
vtl = gis.content.get("<vector tile layer id>")
wm.content.add(vtl.layers[0])
# Move the layer to the basemap
wm.content.move_to_basemap(0)
wm.update()

popup(index: int, is_table: bool = False) → PopupManager

Deprecated since version 2.4.3: Removed in: 2.5.0. Use popup_manager method instead.

Get an instance of the PopupManager class for the layer specified. Specify the layer through it’s position in the list of layers. The list of layers can be accessed with the content.layers property. Through this class you can edit the popup for your layer.

Parameter	Description
index	Required index specifying the layer who’s popup you want to access. To get a full list of layers use the layers property. Note If the layer belongs inside a group layer then use the instance of the Group layer class returned from the layers property to access the layers within the group and to use the popup method in that class.
is_table	Optional boolean. Set to True if the layer is a table.

Returns:: PopupManager class for the layer specified. If popups are not supported for the layer, you will get an error.

popup_manager(index: int, is_table: bool = False) → PopupManager

Get an instance of the PopupManager class for the layer specified. Specify the layer through it’s position in the list of layers. The list of layers can be accessed with the layers property. Through this class you can edit the popup for your layer.

Parameter	Description
index	Required index specifying the layer who’s popup you want to access. To get a full list of layers use the layers property. Note If the layer belongs inside a group layer then use the instance of the Group layer class returned from the layers property to access the layers within the group and to use the popup method in that class.

Returns:: PopupManager class for the layer specified. If popups are not supported for the layer, you will get an error.

remove(index: int | None = None, is_layer: bool = True) → bool

Remove a layer or table from the map either by specifying the index or passing in the layer dictionary.

Parameter	Description
index	Optional integer specifying the index for the layer you want to remove. To see a list of layers use the layers property.
is_layer	Optional boolean. Set to True if removing a layer and False if removing a table.

remove_all() → bool: Remove all layers and tables from the map.

renderer(index) → RendererManager

Deprecated since version 2.4.3: Removed in: 2.5.0. Use renderer_manager method instead.

Get an instance of the RendererManager class for the layer specified. Specify the layer through it’s position in the list of layers. The list of layers can be accessed with the layers property. Through this class you can edit the renderer for your layer.

Parameter	Description
index	Required index specifying the layer who’s renderer you want to access. To get a full list of layers use the layers property. Note If the layer belongs inside a group layer then use the instance of the Group layer class returned from the layers property to access the layers within the group and to use the renderer method in that class.

Returns:: RendererManager class for the layer specified.

renderer_manager(index) → RendererManager

Parameter	Description
index	Required index specifying the layer who’s renderer you want to access. To get a full list of layers use the layers property. Note If the layer belongs inside a group layer then use the instance of the Group layer class returned from the layers property to access the layers within the group and to use the renderer method in that class.

Returns:: RendererManager class for the layer specified.

reposition(current_index: int, new_index: int) → None

Reposition a layer in the Map Content’s layers. You can do this by specifying the index of the current layer you want to move and what index it should be at.

This method is useful if you have overlapping layers and you want to manage the order in which they are rendered on your map.

Parameter

Description

current_index

Required int. The index of where the layer currently is in the list of layers. You can see the list of layers by calling the layers property on your Group Layer instance.

Must be a layer. Cannot be a table.

new_index

Required int. The index you want to move the layer to.

reposition_to_top(index: int) → None

Reposition a layer to the top of the list of layers. This will make the layer render on top of all other layers.

Parameter	Description
index	Required int. The index of the layer you want to reposition to the top of the list.

property table_info: DataFrame: Return a DataFrame with information about the tables in the map.

tables: list

This method can be used to update certain properties on a layer that is in your map.

Parameter	Description
index	Optional integer specifying the index for the layer you want to update. To see a list of layers use the layers property. This cannot be a group layer. To update a group layer, use the update method in the group layer class. It’s better to pass the index to be more specific with which layer you want to update.
labeling_info	Optional list of dictionaries. Defines the properties used for labeling the layer. Example of some properties: labeling_info = [{ “labelExpression”: ‘[FAA_ID]’, “maxScale”: 0, “minScale”: 10000, “symbol”: { “color”: [104, 104, 104, 255], “type”: “esriTS”, “verticalAlignment”: “bottom”, “horizontalAlignment”: “center”, “font”: { “decoration”: “none”, “family”: “Arial”, “size”: 8, “style”: “normal”, “weight”: “bold” } } }]
renderer	Optional Renderer Dataclass. See the renderer module where all the dataclasses are defined.
scale_symbols	Optional bool. Indicates whether symbols should stay the same size in screen units as you zoom in. False means the symbols stay the same size in screen units regardless of the map scale.
transparency	Optional int. Value ranging between 0 (no transparency) to 100 (completely transparent).
options	Optional dictionary. Pass in key, value pairs that will edit the layer properties. This is useful for updating the layer properties that are not exposed through the other parameters. For example, you can update the layer title, opacity, or other properties that are applicable for the type of layer.
form	Optional FormInfo Dataclass. See the forms module where all the dataclasses are defined. You can get the current FormInfo by calling the form property and indicating the index of the layer you want to get the form for. Forms are only supported for Feature Layers, Tables, and Oriented Imagery Layers.

OfflineMapAreaManager

PackagingJob

class arcgis.map.offline_mapping.PackagingJob(future, notify=False)

Bases: object

The PackagingJob class represents a Single Packaging Job.

Parameter	Description
future	Required Future object. The async object created by the `geoprocessing` `GPTask`.
notify	Optional Boolean. When set to `True`, a message will inform the user that the `geoprocessing` task has completed. The default is `False`.

cancel() → bool

The cancel method attempts to cancel the job.

Note

If the call is currently being executed or finished running and cannot be cancelled then the method will return False, otherwise the call will be cancelled and the method will return True.

Returns:: A boolean indicating the call will be cancelled (True), or cannot be cancelled (False)

cancelled() → bool

The cancelled method retrieves whether the call was successfully cancelled.

Returns:: A boolean indicating success (True), or failure (False)

done() → bool

The done method retrieves whether the call was successfully cancelled or finished running.

Returns:: A boolean indicating success (True), or failure (False)

property elapse_time: timedelta | str

Reports the total amount of time that passed while the PackagingJob ran.

Returns:: The elapsed time

result() → Any

The result method retrieves the value returned by the call.

Note

If the call hasn’t yet completed then this method will wait.

Returns:: An Object

running() → bool

The running method retrieves whether the call is currently being executed and cannot be cancelled.

Returns:: A boolean indicating success (True), or failure (False)

property status: str

Get the GP status of the call.

Returns:: A String

Scene

class arcgis.map.scene_widget.Scene(**kwargs: Any)

The Scene can be displayed in a Jupyter Lab environment.

The commands will be sent from the Scene class and all the methods in this class will affect what will be seen on the scene. The underlying web scene dictionary will be transformed in the Scene class.

A Scene contains layers of geographic data that are displayed in 3D. Scenes allow you to display real-world visualizations of landscapes, objects, buildings, and other 3D objects.

property basemap: BasemapManager: Returns a BasemapManager object that can be used to handle basemap related properties and methods on the Scene.

property camera

Get/Set the camera of the rendered Scene.

Parameter

Description

camera

A dictionary that represents the JSON of the scene widget’s camera. The dictionary included the keys: “position”, “heading”, and “tilt” The position indicates the x, y, and z coordinates for the camera. The heading is the heading of the camera in degrees. The tilt is the degrees with respect to the surface as projected down.

Example: scene.camera = {

“position”:{
‘x’: -5938587.158752469, ‘y’: -2827970.414173906, ‘z’: 46809.31127560418

}, “heading”: 400, “tilt”: 0.5

}

Returns:: A dictionary that represents the x,y, and z of the rendered Scene.

# Usage example
scene.camera = {
    "position":{
        'x': -5938587.158752469,
        'y': -2827970.414173906,
        'z': 46809.31127560418
    },
    "heading": 400,
    "tilt": 0.5
}

property center

Get/Set the center of the rendered Scene.

Parameter	Description
center	A [lat, long] list that represents the JSON of the scene widget’s center.

Returns:: A list that represents the latitude and longitude of the scene’s center.

# Usage example
scene.center = [34.05, -118.24]

property content: SceneContent: Returns a SceneContent object that can be used to access the layers and tables in the scene. This is useful for adding, updating, getting, and removing content from the Scene.

property environment: Environment: Get an instance of the Environment class. You can use this class to enable or disable widgets such as weather and daylight. You can also set these properties using python code.

property extent

Get/Set the rendered map’s extent.

Note

Must provide a spatial reference key in the extent dictionary.

Parameter

Description

value

Required dict. map.extent = {

‘spatialReference’: {‘latestWkid’: 3857, ‘wkid’: 102100}, ‘xmax’: 5395723.072123609, ‘xmin’: -137094.78326911852, ‘ymax’: 10970767.576996306, ‘ymin’: 7336034.007980572

}

Returns:: A dictionary representing the extent

property heading: float

Get/Set the heading of the camera in degrees. Heading is zero when north is the top of the screen. It increases as the view rotates clockwise.

Parameter	Description
heading	A float that represents the heading in degrees.

js_api_path: A trait for unicode strings.

js_requirement()

Returns:: A dictionary in the format: {“JS_API”: <version_number>}.

property layer_list: LayerList: Get an instance of the LayerList class. You can use this class to enable or disable the layer list widget. Best used inside of Jupyter Lab.

property legend: Legend: Get an instance of the Legend class. You can use this class to enable or disable the legend widget. Best used inside of Jupyter Lab.

save(item_properties: dict[str, Any], thumbnail: str | None = None, metadata: str | None = None, owner: str | None = None, folder: str | None = None) → Item

Saves the Scene object as a new Web Scene Item in your GIS.

Note

If you started with a Scene object from an existing web scene item, calling this method will create a new item with your changes. If you want to update the existing Scene item found in your portal with your changes, call the update method instead.

Parameter	Description
item_properties	Required dictionary. See table below for the keys and values. The three required keys are: ‘title’, ‘tag’, ‘snippet’.
thumbnail	Optional string. Either a path or URL to a thumbnail image.
metadata	Optional string. Either a path or URL to the metadata.
owner	Optional string. Defaults to the logged in user.
folder	Optional string. Name of the folder into which the web scene should be saved.

Key:Value Dictionary Options for Argument item_properties

Key	Value
title	Required string. Name label of the item.
tags	Required string. Tags listed as comma-separated values, or a list of strings. Used for searches on items.
snippet	Required string. Provide a short summary (limit to max 250 characters) of the what the item is.
typeKeywords	Optional string. Provide a lists all subtypes, see URL 1 below for valid values.
description	Optional string. Description of the item.
extent	Optional dict. The extent of the item.
accessInformation	Optional string. Information on the source of the content.
licenseInfo	Optional string. Any license information or restrictions regarding the content.
culture	Optional string. Locale, country and language information.
access	Optional string. Valid values are private, shared, org, or public.
commentsEnabled	Optional boolean. Default is true, controls whether comments are allowed (true) or not allowed (false).
culture	Optional string. Language and country information.

The above are the most common item properties (metadata) that you set. To get a complete list, see the Common Parameters page in the ArcGIS REST API documentation.

Returns:

Item object corresponding to the new web scene Item created.

# save the web scene webscene_item_properties = {‘title’:’Ebola incidents and facilities’,

’snippet’:’Scene created using Python API showing locations of Ebola treatment centers’, ‘tags’:[‘automation’, ‘ebola’, ‘world health’, ‘python’], ‘extent’: {‘xmin’: -122.68, ‘ymin’: 45.53, ‘xmax’: -122.45, ‘ymax’: 45.6, ‘spatialReference’: {‘wkid’: 4326}}}

new_ws_item = webscene.save(webscene_item_properties, thumbnail=’./webscene_thumbnail.png’)

property scale: Get/Set the scene scale at the center of the rendered Scene. If set to X, the scale of the scene would be 1:X.

sync_navigation(scene: Scene | list[Scene]) → None

The sync_navigation method synchronizes the navigation from one rendered Scene to another rendered Scene instance so panning/zooming/navigating in one will update the other.

Note

Users can sync more than two instances together by passing in a list of Scene instances to sync. The syncing will be remembered

Parameter	Description
scene	Either a single Scene instance, or a list of `Scene` instances to synchronize to.

theme

Get/Set the widget theme when displaying in a Jupyter environment.

Values can be “light” or “dark”

property tilt: float

Get/Set the tilt of the rendered Scene. The tilt of the camera in degrees with respect to the surface as projected down from the camera position. Tilt is zero when looking straight down at the surface and 90 degrees when the camera is looking parallel to the surface.

Parameter	Description
tilt	A float that represents the tilt.

Returns:: A float that represents the tilt value.

property time_slider: TimeSlider: Get an instance of the TimeSlider class. You can use this class to enable or disable the time slider on the widget. Best used inside of Jupyter Lab

unsync_navigation(scene: Scene | list[Scene] | None = None) → None

The unsync_navigation method unsynchronizes connections made to other rendered Scene instances made via the sync_navigation method.

Parameter	Description
scene	Optional, either a single Scene instance, or a list of Scene instances to unsynchronize. If not specified, will unsynchronize all synced Scene instances.

update(item_properties: dict[str, Any] | None = None, thumbnail: str | None = None, metadata: str | None = None) → bool

The update method updates the Web Scene Item in your GIS with the changes you made to the Scene object. In addition, you can update other item properties, thumbnail and metadata.

Note

If you started with a Scene object from an existing web scene item, calling this method will update the item with your changes.

If you started out with a fresh Scene object (without a web scene item), calling this method will raise a RuntimeError exception. If you want to save the Scene object into a new web scene item, call the save method instead.

Parameter	Description
item_properties	Optional dictionary. See table below for the keys and values.
thumbnail	Optional string. Either a path or URL to a thumbnail image.
metadata	Optional string. Either a path or URL to the metadata.

Key:Value Dictionary Options for Argument item_properties

Key	Value
typeKeywords	Optional string. Provide a lists all sub-types, see URL 1 below for valid values.
description	Optional string. Description of the item.
title	Optional string. Name label of the item.
tags	Optional string. Tags listed as comma-separated values, or a list of strings. Used for searches on items.
snippet	Optional string. Provide a short summary (limit to max 250 characters) of the what the item is.
accessInformation	Optional string. Information on the source of the content.
licenseInfo	Optional string. Any license information or restrictions regarding the content.
culture	Optional string. Locale, country and language information.
access	Optional string. Valid values are private, shared, org, or public.
commentsEnabled	Optional boolean. Default is true, controls whether comments are allowed (true) or not allowed (false).

The above are the most common item properties (metadata) that you set. To get a complete list, see the common parameters page in the ArcGIS REST API documentation.

Returns:: A boolean indicating success (True) or failure (False).

property viewing_mode: str

Get/Set the viewing mode.

The viewing mode (local or global). Global scenes render the earth as a sphere. Local scenes render the earth on a flat plane and allow for navigation and feature display in a localized or clipped area. Users may also navigate the camera of a local scene below the surface of a basemap.

“global” : Global scenes allow the entire globe to render in the view, showing the curvature of the earth.
“local” : Local scenes render the earth on a flat surface. They can be constrained to only show a “local”

area by setting the clippingArea property. Local scenes also allow for displaying and exploring data that would otherwise be hidden by the surface of the earth.

Parameter	Description
mode	A string that represents the mode. Either “global” or “local”. Default is “global”.

Returns:: String that represents the viewing mode.

property zoom

Get/Set the level of zoom applied to the rendered Scene.

Parameter	Description
value	Required int. .. note: The higher the number, the more zoomed in you are.

Returns:: Int value that represents the zoom level

# Usage example
scene.zoom = 10

The zoom_to_layer method snaps the scene to the extent of the provided Item object(s).

Parameter	Description
item	The item at which you want to zoom your scene to. This can be a single extent or an `Item`, `Layer` , `DataFrame` , `FeatureSet`, or `FeatureCollection` object.

Scene Classes

Environment

class arcgis.map.scene_widget.Environment(scene: Scene)

A class that can be used to enable the environment widgets such as daylight and weather on a rendered Scene. This class is most useful when used inside a Jupyter Lab environment.

Note

This class should now be created by a user but rather called through the environment property on a Scene instance.

property daylight_enabled: bool: The Daylight widget can be used to manipulate the lighting conditions of a Scene. For this, the widget modifies the lighting property of environment. To illuminate the scene, one can either use a configuration of date and time to position the sun or switch to the virtual mode, where the light source is relative to the camera.

property weather_enabled: bool: The Daylight widget can be used to manipulate the lighting conditions of a Scene. For this, the widget modifies the lighting property of environment. To illuminate the scene, one can either use a configuration of date and time to position the sun or switch to the virtual mode, where the light source is relative to the camera.

SceneContent

class arcgis.map.scene_widget.SceneContent(scene: Scene)

This class allows users to manage the content of a Scene. Users can view the operational layers, add layers, reorder layers, and remove layers.

This class is created from the scene_content property on a Scene instance.

add(item: Item | Layer, drawing_info: dict | None = None, popup_info: dict | None = None, index: int | None = None) → None

Add a layer or table to the scene.

Parameter	Description
item	Required Portal Item or Layer to add to the scene. If an item is passed in: Creates a new layer instance of the appropriate layer class from an ArcGIS Online or ArcGIS Enterprise portal item. * If the item points to a feature service with multiple layers, then a GroupLayer is created. * If the item points to a service with a single layer, then it resolves to a layer of the same type of class as the service.
drawing_info	Optional dictionary representing the drawing info to apply to the layer. The keys can include any combination of: ‘renderer’, ‘labelingInfo’, ‘scaleSymbols’, ‘showLabels’, ‘transparency’. This can only be applied when adding one layer. NOTICE: The scene viewer only accepts 3D Symbols. Please see: 3D Symbols for more information. Example Structure: drawing_info = { “labelingInfo”: <list>, “renderer”: <dict>, “scaleSymbols”: <bool>, “showLabels”: <bool>, “transparency”: <float> }
popup_info	Optional dictionary representing the popup info for the feature layer. This can only be applied when adding one layer. Example: popup_info = { “popupElements”: <list>, “showAttachments”: <bool>, “fieldInfos”: <list>, “title”: <str> }
index	Optional integer. Determines at what index the layer should be added.

clear_cache()

get_layer(title: str) → Layer

Get a layer or table from the scene by title. If the layer is added more than once only the first instance of the layer will be returned.

..note::: To find a layer by index you can use the layer_info method to see the layers in a table form.

Returns:: A layer or table from the scene.

layer_info()

Get the layers in the scene.

Returns:: A list of dictionaries representing the layers in the scene.

layer_visibility(index: int) → LayerVisibility

Parameter	Description
index	Required index specifying the layer who’s visibility properties you want to access. To get a full list of layers use the layers property. Note If the layer belongs inside a group layer then use the instance of the Group layer class returned from the layers property to access the layers within the group and to use the layer_visibility method in that class.

Returns:: LayerVisibility class for the layer specified.

layers: list

move_to_basemap(index: int) → None

Move a layer to be a basemap layer. A basemap layer is a layer that provides geographic context to the scene. A web scene always contains a basemap. The following is a list of possible basemap layer types:

Image Service Layer
Image Service Vector Layer
Map Service Layer
Tiled Image Service Layer
Tiled Map Service Layer
Vector Tile Layer

Parameter	Definition
index	Required integer. The index of the layer from operational layers that will be moved to basemap layers. The list of available layers is found when calling the layers property on the Scene.

# Create a Scene from an existing Scene Item.
ws = Scene(item=<webscene_item_id>)
# Get and add the layer to the scene
vtl = gis.content.get("<vector tile layer id>")
ws.content.add(vtl.layers[0])
# Move the layer to the basemap
ws.move_to_basemap(0)
ws.update()

popup(index: int) → PopupManager

Parameter	Description
index	Required index specifying the layer who’s popup you want to access. To get a full list of layers use the layers property. Note If the layer belongs inside a group layer then use the instance of the Group layer class returned from the layers property to access the layers within the group and to use the popup method in that class.

Returns:: PopupManager class for the layer specified.

remove(index: int | None = None, is_layer: bool = True) → bool

Remove a layer from the scene either by specifying the index or passing in the layer dictionary.

Parameter	Description
layer	Optional layer object from the list of layers found through the layers property that you want to remove from the scene. This will remove the first instance of this layer if you have it more than once on the scene. This parameter cannot be passed with the index.
index	Optional integer specifying the index for the layer you want to remove. To see a list of layers use the layers property.

remove_all() → bool: Remove all layers and tables from the scene.

tables: list

This method can be used to update certain properties on a layer that is in your scene.

Parameter	Description
index	Optional integer specifying the index for the layer you want to update. To see a list of layers use the layers property. This cannot be a group layer. To update a group layer, use the update_layer method in the group layer class. It’s better to pass the index to be more specific with which layer you want to update.
labeling_info	Optional list of dictionaries. Defines the properties used for labeling the layer. Example of some properties: labeling_info = [{ “labelExpression”: ‘[FAA_ID]’, “maxScale”: 0, “minScale”: 10000, “symbol”: { “color”: [104, 104, 104, 255], “type”: “esriTS”, “verticalAlignment”: “bottom”, “horizontalAlignment”: “center”, “font”: { “decoration”: “none”, “family”: “Arial”, “size”: 8, “style”: “normal”, “weight”: “bold” } } }]
renderer	Optional Renderer Dataclass. See the renderer module where all the dataclasses are defined.
scale_symbols	Optional bool. Indicates whether symbols should stay the same size in screen units as you zoom in. False means the symbols stay the same size in screen units regardless of the scene scale.
transparency	Optional int. Value ranging between 0 (no transparency) to 100 (completely transparent).

Common Classes for Map and Scene

Legend

class arcgis.map.map_widget.Legend(map)

The Legend describes the symbols used to represent layers in a map. All symbols and text used in this widget are configured in the Renderer of the layer. The legend will only display layers and sub-layers that are visible in the map.

The legend automatically updates when - the visibility of a layer or sub-layer changes - a layer is added or removed from the map - a layer’s renderer, opacity, or title is changed - the legendEnabled property is changed (set to true or false on the layer)

Note

This class should now be created by a user but rather called through the legend property on a Map instance.

property enabled: bool

Get and set whether the legend is shown on the map/scene or not. Set to True for the legend to be visible.

The Legend widget describes the symbols used to represent layers in a map. All symbols and text used in this widget are configured in the renderer of the layer. The legend will only display layers and sub-layers that are visible in the map.

The legend automatically updates when - the visibility of a layer or sub-layer changes - a layer is added or removed from the map - a layer’s renderer, opacity, or title is changed

Note

Known Limitations: - Currently, the legend widget does not support the following layer types: ElevationLayer, GraphicsLayer, IntegratedMeshLayer, KMLLayer, MapNotesLayer, OpenStreetMapLayer, VectorTileLayer, and WebTileLayer. - 3D symbols with more than one symbol layer are not supported. - DictionaryRenderer is not supported.

LayerVisibility

class arcgis.map.map_widget.LayerVisibility(layer: Layer)

A class that can be used to manage the visibility of layers in a map. The layer visibility class is primarily used to set the visibility of the layers on the map and in the legend.

Note

This class should now be created by a user but rather called through the layer_visibility property on a Map or GroupLayer instance.

property legend_visibility: bool: Get and Set the visibility of the layer in the legend. Set to True for the layer to be visible in the legend and False otherwise.

property visibility: bool: Get and Set the visibility of the layer. Set to True for the layer to be visible and False otherwise.

LayerList

class arcgis.map.map_widget.LayerList(map)

A class that can be used to enable the layer list widget on a rendered Map. This class is most useful when used inside a Jupyter Lab environment.

Note

This class should now be created by a user but rather called through the layer_list property on a Map instance.

property enabled: bool: The Layer List widget allows end users to quickly see the layers that are present on your map. It displays a list of layers, which are defined inside the Map. Set to True for the layer list to be visible. This property is best used inside Jupyter Lab with a rendered Map.

Note

Any changes made on the layer list widget will only be reflected in the rendered map instance, these will not affect the map definition. To change layer visibility in the definition, use the layer_visibility method.

TimeSlider

class arcgis.map.map_widget.TimeSlider(map)

A class that can be used to enable the time slider widget on a rendered Map. This class is most useful when used inside a Jupyter Lab environment.

Note

This class should now be created by a user but rather called through the time_slider property on a Map instance.

property enabled: bool: The TimeSlider widget simplifies visualization of temporal data in your application.

Note

The TimeSlider widget is only available for layers that have time information enabled.

time_extent(start_time: datetime | None = None, end_time: datetime | None = None, time_interval: dict | None = None, layer_idx: int = 0)

The time_extent is called when enabled = True and is the full time extent to display on the time slider.

Parameter	Description
start_time	Optional `datetime.datetime`. The lower bound of the full time extent to display on the time slider.
end_time	Optional `datetime.datetime`. The upper bound of the full time extent to display on the time slider.
time_interval	Optional dict. The time interval to display on the time slider. The time interval is a dictionary with two keys: value and units. The interval is the number of units to display on the time slider. The units are the units of the interval.
layer_idx	Optional integer. The index of the layer in the webmap that the time extent should be applied to. If not specified, the time extent will be applied to the first layer in the webmap.

BasemapManager

class arcgis.map.map_widget.BasemapManager(map)

The Basemap Manager allows users to manage the basemap of a webmap or webscene. Users can view their basemap options, set the basemap to a new one, and add layers to the basemap.

This class is created from the basemap property on a Map or Scene instance.

property basemap: str | Item

Get and/or set the current basemap of the Map or Scene. Basemap values can be found by calling the basemaps or basemap_gallery property. An existing web map Item type can also be assigned, and then its basemap will be set as the map object’s basemap.

Setting the basemap will replace all current basemap layers with the new basemap’s layers.

To use the ArcGIS Basemap Styles service to set the basemap, pass a basemap style to use.

Note

Only works on rendered map instances.

# Usage Example #1: Set the basemap with the styles service

>>> from arcgis.gis import GIS

>>> gis = GIS(profile="your_online_profile")
>>> new_map = gis.map("Geneva")

>>> styles_svc = new_map.basemap.basemap_styles_service

>>> styles_svc.styles_names

['ArcGIS Imagery',
 'ArcGIS Imagery Standard',
 'ArcGIS Dark Gray'
 ...
 'Open Basemaps OpenStreetMap Style']

>>> dark_gray_style = styles_svc.get_style("ArcGIS Dark Gray")

>>> new_map.basemap.basemap = dark_gray_style

# Usage Example #2: Set the basemap with value from *basemaps* list

>>> new_map.basemap.basemaps
['satellite'
 'hybrid',
 ...
 'osm-streets']

>>> new_map.basemap.basemap = "satellite"
# visible in rendered map in an ArcGIS Notebook

Note

If you set a basemap with a different spatial reference than a webmap or webscene, any operational layers on the original map will not be re-projected automatically.

property basemap_gallery: list[str]: The basemap_gallery property allows for viewing of your portal’s custom basemap group.

property basemap_styles_service: BasemapStylesService: This property returns a BasemapStylesService object providing access to the ArcGIS Basemap Styles service. It allows users to retrieve and manage basemap style objects for use in ArcGIS Notebooks and mapping applications.

Note

Only available in ArcGIS Online or Location Platform.

property basemaps: list[str]: List of possible basemaps to use. All those starting with ‘arcgis’ require you to be authenticated.

property basemaps3d: list[str]: List of possible 3D basemaps to use with a Scene. All those starting with ‘arcgis’ require you to be authenticated.

property layers: List of layers in the basemap.

move_from_basemap(index: int) → bool

Move a layer from the basemap layers to the operational layers. The reverse process of move_to_basemap.

Parameter	Definition
index	Required integer. The index of the layer found in the basemap layers that will be moved to be in the operational layers.

wm = Map(item=<webmap_item_id>)
layer = wm.basemap["baseMapLayer"][0]
wm.move_from_basemap()
wm.update()

remove_basemap_layer(index: int) → bool

Remove a layer from the basemap layers. You can see the current basemap layers by calling the basemap property on your map. If you want to update the title of the basemap you can use the basemap_title method.

Note

There must be at least one basemap layer present. You cannot remove all basemap layers.

Parameter	Definition
index	Required integer. The index for the layer in the basemap layers that will be removed.

property title

Get/Set the basemap title.

Parameter	Definition
title	Required string. The title to set for the basemap.

Basemap Styles Services

BasemapStylesService

BasemapStyle

Basemap Styles Enumerations

BasemapStylesLanguage

class arcgis.map.BasemapStylesLanguage(*values)

ARABIC = 'ar'

BOSNIAN = 'bs'

BULGARIAN = 'bg'

CATALAN = 'ca'

CHINESE_HONG_KONG = 'zh-HK'

CHINESE_SIMPLIFIED = 'zh-CN'

CHINESE_TAIWAN = 'zh-TW'

CROATIAN = 'hr'

CZECH = 'cs'

DANISH = 'da'

DUTCH = 'nl'

ENGLISH = 'en'

ESTONIAN = 'et'

FINNISH = 'fi'

FRENCH = 'fr'

GERMAN = 'de'

GLOBAL = 'global'

GREEK = 'el'

HEBREW = 'he'

HUNGARIAN = 'hu'

INDONESIAN = 'id'

ITALIAN = 'it'

JAPANESE = 'ja'

KOREAN = 'ko'

LATVIAN = 'lv'

LITHUANIAN = 'lt'

LOCAL = 'local'

NORWEGIAN = 'no'

NORWEGIAN_BOKMAL = 'nb'

POLISH = 'pl'

PORTUGUESE_BRAZIL = 'pt-BR'

PORTUGUESE_PORTUGAL = 'pt-PT'

ROMANIAN = 'ro'

RUSSIAN = 'ru'

SERBIAN = 'sr'

SLOVAK = 'sk'

SLOVENIAN = 'sl'

SPANISH = 'es'

SWEDISH = 'sv'

THAI = 'th'

TURKISH = 'tr'

UKRAINIAN = 'uk'

VIETNAMESE = 'vi'

BasemapStylesPlace

class arcgis.map.BasemapStylesPlace(*values)

ALL = 'all'

ATTRIBUTED = 'attributed'

NONE = 'none'

BasemapStylesWorldview

class arcgis.map.BasemapStylesWorldview(*values)

CHINA = 'china'

INDIA = 'india'

ISRAEL = 'israel'

JAPAN = 'japan'

MOROCCO = 'morocco'

NONE = 'none'

PAKISTAN = 'pakistan'

SOUTH_KOREA = 'southKorea'

UNITED_ARAB_EMIRATES = 'unitedArabEmirates'

UNITED_STATES = 'unitedStatesOfAmerica'

VIETNAM = 'vietnam'

GroupLayer

class arcgis.map.group_layer.GroupLayer(group_layer: Layer, map: Map | Scene, parent: BaseGroup | Map | Scene)

Provides the ability to organize several layers into one common layer in a map instance. For example, if there are several feature layers that all represent water features, they can be organized as sublayers of a group layer in a web map.

Note

This class is not created by user directly, but is populated by accessing the layers property of a MapContent object and assigning a variable to the index position within the map content layers`.

from arcgis.gis import GIS
from arcgis.map import Map

gis = GIS(profile="your_organization_profile")

wm_item = gis.content.search(
              query=f"title:{Water *} and owner:{gis.users.me.username}",
              item_type="Web Map"
)[0]

wm_obj = Map(item=wm_item)
map_content = wm_obj.content
map_content.layers

>>>[GroupLayer(title=City Water Administration),
    <FeatureLayer url:"https://services7.arcgis.com/<org_id>.../city_limit/FeatureServer/0">]

grp_lyr = map_content.layers[0]
grp_lyr

>>> GroupLayer(title=City Water Administration)

form_manager(index: int)

Get an instance of the FormManager class for managing the forms of the specified map layer.

Parameter	Description
index	Required integer specifying the index position of the layer whose `FormManager` will be accessed. Layer needs to be in the list of layers retrieved from the layer_info property on a `GroupLayer`, `SubtypeGroupLayer` or `MapContent` object.

property layer_info: DataFrame

Get a Pandas DataFrame with index position, title, and type of each layer in the GroupLayer.

Returns:: Pandas DataFrame with information about sublayers.

# Usage Example: Get the PopupManager for a layer in map Group layer
from arcgis.gis import GIS
from arcgis.map import Map

gis = GIS(profile="your_organization_profile")

webmap_item = gis.content.get("<item_id>")

webmap_obj = Map(item=webmap_item)
print(webmap_obj.content.layers)

>>>
   [GroupLayer(title=Conservation Administration),
    <FeatureLayer url:"https://services7.arcgis.com/<org_id>/.../habitats/FeatureServer/0">]

map_grplyr = webmap_obj.content.layers[0]
map_grplyr.layer_info

>>>
    Layer Index         Layer Title          Layer Type
0           0         Critical areas       ArcGIS Feature Layer
1           1         Townships            ArcGIS Feature Layer
2           2     City land boundary   ArcGIS Feature Layer

layer_visibility(index: int)

Get an instance of the LayerVisibility class for managing the visibility of the specified map layer.

Parameter	Description
index	Required integer specifying the index position of the layer whose `LayerVisibility` will be managed. Layer needs to be in the list of layers retrieved from the layer_info property on a `GroupLayer`, `SubtypeGroupLayer` or `MapContent` object.

Returns:: A LayerVisiblity object for the specified layer.

# Usage Example: Get an object to manager the visiblity of
# one subtype layer in a SubtypeGroupLayer

from argis.gis import GIS
from arcgis.map import Map

gis = GIS(profile="your_organization_profile")

wm_item = gis.content.search(query="Damage *", item_type="Web Map")[0]

map_obj = Map(item=wm_item)

map_obj.content.layer_info

>>>
      Layer Index        Layer Title                    Layer Class
    0         0             Water_Infrastructure    SubtypeGroupLayer(title=Water Infrastructure)

subtype_grplyr = map_obj.content.layers[0]
subtype_grplyr.layer_info

>>>
      Layer Index         Layer Title          Layer Type
    0       0               TIDAL_WATER_S       ArcGIS Feature Layer
    1       1               SPILLWAY_S          ArcGIS Feature Layer
    2       2               RIVER_S             ArcGIS Feature Layer
    3       3               RAPIDS_S            ArcGIS Feature Layer
    4       4               DAM_S               ArcGIS Feature Layer

lv_3 = subtype_grplyr.layer_visibility(index=3)
lv_3

>>> LayerVisibility(layer=RAPIDS_S)

property layers: list

Get the list of layers in the group layer.

Returns the user-facing Python API layer objects: - FeatureLayer, MapImageLayer, VectorTileLayer, GroupLayer, etc.

move(index: int, group: GroupLayer | None = None) → None

Move a layer from its group into another GroupLayer or into ‘No Group’ which means it will be moved to the main Map’s layers.

You can use this method on a GroupLayer and the entire GroupLayer will be added to another group or be added to the main Map’s layers.

Parameter	Description
index	Required int. The index of the layer you want to move. You can see the list of layers by calling the layers property on your Group Layer instance.
group	Optional GroupLayer. The group layer you want to move the layer to. If you want to move the layer to the main Map’s layers, pass in None.

popup_manager(index: int)

Get an instance of the PopupManager for the layer specified with the index value. Specify the layer through it’s index position, which is accessible with the layer_info property on the following class instances:

a GroupLayer object
a SubtypeGroupLayer object
a MapContent object

Parameter	Description
index	Required integer specifying the index position of the layer whose popup will be managed. The index position can be retrieved from the the layer_info property on a `MapContent`, `GroupLayer`, or `SubtypeGroupLayer` object.

Returns:: PopupManager instance for the layer specified.

# Usage Example: Get the PopupManager for a layer in map Group layer
from arcgis.gis import GIS
from arcgis.map import Map

gis = GIS(profile="your_organization_profile")

webmap_item = gis.content.get("<item_id>")

webmap_obj = Map(item=webmap_item)
print(webmap_obj.content.layers)

>>>
   [GroupLayer(title=Conservation Administration),
    SubtypeGroupLayer(title=Water_bodies),
    <FeatureLayer url:"https://services7.arcgis.com/<org_id>/arcgis/rest/services/conservation_areas/FeatureServer/0">]

map_grplyr = webmap_obj.content.layers[0]
map_grplyr.layer_info

>>>
    Layer Index         Layer Title          Layer Type
0           0         Proteced areas       ArcGIS Feature Layer
1           1         Townships            ArcGIS Feature Layer
2           2     Easement boundaries  ArcGIS Feature Layer

easement_pmgr = map_grplyr.popup_manager(index=2)
easement_pmgr

PopupManager(layer=Easement boundaries)

remove_layer(index: int) → None

Remove a layer from the GroupLayer’s layers by index.

Parameter	Description
index	Required int. The index of the layer you want to remove. You can see the list of layers by calling the layers property on your Group Layer instance.

renderer_manager(index: int)

Get an instance of the RendererManager class for the specified map layer. Specify the layer through it’s index position accessed from the layer_info property on GroupLayer, SubtypeGroupLayer or MapContent object.

Parameter	Description
index	Required integer specifying the layer who’s renderer to get. Layer has to be in list of layers of the Group Layer instance. You can get the list of layers by calling the layers property on your Group Layer instance.

Returns:: RendererManager instance for the layer specified.

# Usage Example: Get the RendererManager from a map's MapContent object
from arcgis.gis import GIS
from arcgis.map import Map

gis = GIS(profile="your_organization_profile")

webmap_item = gis.content.get("<item_id>")

webmap_obj = Map(item=webmap_item)
print(webmap_obj.content.layers)

>>>
   [<FeatureLayer url:"https://services7.arcgis.com/<org_id>/.../hazard_areas/FeatureServer/0">>
    <FeatureLayer url:"https://services7.arcgis.com/<org_id>/.../safe_zones/FeatureServer/3">]

map_content = webmap_obj.content
map_content.layer_info

>>>
    Layer Index         Layer Title            Layer Type
0           0         Hazardous Waste areas    ArcGIS Feature Layer
1           1         Barricaded safe zones    ArcGIS Feature Layer

waste_renderer = map_content.renderer_manager(index=0)

>>> RendererManager(layer=Hazardaous Waste areas)

ungroup() → None

Un-group a GroupLayer. This will send the layer’s children to the parent’s layers.

If the parent is Map, then all the layers in the GroupLayer will be sent to the Map’s operational_layers and the GroupLayer removed.
If the parent is another GroupLayer, then all the layers in the GroupLayer will be sent to the parent’s layers and the GroupLayer removed.

SubtypeGroupLayer

class arcgis.map.group_layer.SubtypeGroupLayer(group_layer: SubtypeGroupLayer, map: Map | Scene, parent: BaseGroup | Map | Scene)

A SubtypeGroupLayer represents a single feature service layer that contains multiple subtypes, each of which can be displayed with its own title, renderer, popup configuration, form, and editing properties.

Unlike a regular GroupLayer, the sublayers inside a SubtypeGroupLayer (instances of SubtypeLayer) are not separate service layers, do not have their own REST URLs, and cannot be queried or managed independently on the service. All subtype layers share:

the same URL (the parent feature layer’s URL)
the same dataset
the same REST endpoint
the same feature service layer ID

Because subtype layers are not standalone layers, the Python API does not expose them as a `.layers` property. Instead, you can inspect them using the layer_info() property of SubtypeGroupLayer or manage their individual display properties using the appropriate manager classes:

popup_manager(index)

renderer_manager(index)

form_manager(index)

layer_visibility(index)

These managers allow modifying the popup, renderer, form, and visibility settings that are stored in the WebMap specification for each subtype, without implying that subtype layers can be manipulated like normal map layers.

Key Concept:

A SubtypeGroupLayer looks like a group of layers in the Map Viewer, but technically it represents one layer with multiple subtype definitions.

Example

>>> layer = m.content.layers[0]
>>> layer.layer_info
  Layer Index Layer Title            Layer Type
0            0  Washington  ArcGIS Feature Layer
1            1      Oregon  ArcGIS Feature Layer
2            2  California  ArcGIS Feature Layer

This class is intended to be accessed through the layers property of a Map or the layers property of a GroupLayer. Users should not instantiate it directly.

form_manager(index: int)

Get an instance of the FormManager class for managing the forms of the specified map layer.

Parameter	Description
index	Required integer specifying the index position of the layer whose `FormManager` will be accessed. Layer needs to be in the list of layers retrieved from the layer_info property on a `GroupLayer`, `SubtypeGroupLayer` or `MapContent` object.

property layer_info: DataFrame

Get a Pandas DataFrame with index position, title, and type of each layer in the SubtypeGroupLayer.

# Usage Example: Get the infromation about sublayers in SubtypeGroupLayer
from argis.gis import GIS
from arcgis.map import Map

gis = GIS(profile="your_organization_profile")

wm_item = gis.content.search(query="Damage *", item_type="Web Map")[0]

map_obj = Map(item=wm_item)

map_obj.content.layer_info

>>>
      Layer Index   Layer Title                 Layer Class
    0         0             Water_Infrastructure    SubtypeGroupLayer(title=Water Infrastructure)

subtype_grplyr = map_obj.content.layers[0]
subtype_grplyr.layer_info

>>>
      Layer Index        Layer Title          Layer Type
    0       0               TIDAL_WATER_S       ArcGIS Feature Layer
    1       1               SPILLWAY_S          ArcGIS Feature Layer
    2       2               RIVER_S             ArcGIS Feature Layer
    3       3               RAPIDS_S            ArcGIS Feature Layer
    4       4               DAM_S               ArcGIS Feature Layer

layer_visibility(index: int)

Get an instance of the LayerVisibility class for managing the visibility of the specified map layer.

Parameter	Description
index	Required integer specifying the index position of the layer whose `LayerVisibility` will be managed. Layer needs to be in the list of layers retrieved from the layer_info property on a `GroupLayer`, `SubtypeGroupLayer` or `MapContent` object.

Returns:: A LayerVisiblity object for the specified layer.

# Usage Example: Get an object to manager the visiblity of
# one subtype layer in a SubtypeGroupLayer

from argis.gis import GIS
from arcgis.map import Map

gis = GIS(profile="your_organization_profile")

wm_item = gis.content.search(query="Damage *", item_type="Web Map")[0]

map_obj = Map(item=wm_item)

map_obj.content.layer_info

>>>
      Layer Index        Layer Title                    Layer Class
    0         0             Water_Infrastructure    SubtypeGroupLayer(title=Water Infrastructure)

subtype_grplyr = map_obj.content.layers[0]
subtype_grplyr.layer_info

>>>
      Layer Index         Layer Title          Layer Type
    0       0               TIDAL_WATER_S       ArcGIS Feature Layer
    1       1               SPILLWAY_S          ArcGIS Feature Layer
    2       2               RIVER_S             ArcGIS Feature Layer
    3       3               RAPIDS_S            ArcGIS Feature Layer
    4       4               DAM_S               ArcGIS Feature Layer

lv_3 = subtype_grplyr.layer_visibility(index=3)
lv_3

>>> LayerVisibility(layer=RAPIDS_S)

popup_manager(index: int)

a GroupLayer object
a SubtypeGroupLayer object
a MapContent object

Parameter	Description
index	Required integer specifying the index position of the layer whose popup will be managed. The index position can be retrieved from the the layer_info property on a `MapContent`, `GroupLayer`, or `SubtypeGroupLayer` object.

Returns:: PopupManager instance for the layer specified.

# Usage Example: Get the PopupManager for a layer in map Group layer
from arcgis.gis import GIS
from arcgis.map import Map

gis = GIS(profile="your_organization_profile")

webmap_item = gis.content.get("<item_id>")

webmap_obj = Map(item=webmap_item)
print(webmap_obj.content.layers)

>>>
   [GroupLayer(title=Conservation Administration),
    SubtypeGroupLayer(title=Water_bodies),
    <FeatureLayer url:"https://services7.arcgis.com/<org_id>/arcgis/rest/services/conservation_areas/FeatureServer/0">]

map_grplyr = webmap_obj.content.layers[0]
map_grplyr.layer_info

>>>
    Layer Index         Layer Title          Layer Type
0           0         Proteced areas       ArcGIS Feature Layer
1           1         Townships            ArcGIS Feature Layer
2           2     Easement boundaries  ArcGIS Feature Layer

easement_pmgr = map_grplyr.popup_manager(index=2)
easement_pmgr

PopupManager(layer=Easement boundaries)

renderer_manager(index: int)

Parameter	Description
index	Required integer specifying the layer who’s renderer to get. Layer has to be in list of layers of the Group Layer instance. You can get the list of layers by calling the layers property on your Group Layer instance.

Returns:: RendererManager instance for the layer specified.

# Usage Example: Get the RendererManager from a map's MapContent object
from arcgis.gis import GIS
from arcgis.map import Map

gis = GIS(profile="your_organization_profile")

webmap_item = gis.content.get("<item_id>")

webmap_obj = Map(item=webmap_item)
print(webmap_obj.content.layers)

>>>
   [<FeatureLayer url:"https://services7.arcgis.com/<org_id>/.../hazard_areas/FeatureServer/0">>
    <FeatureLayer url:"https://services7.arcgis.com/<org_id>/.../safe_zones/FeatureServer/3">]

map_content = webmap_obj.content
map_content.layer_info

>>>
    Layer Index         Layer Title            Layer Type
0           0         Hazardous Waste areas    ArcGIS Feature Layer
1           1         Barricaded safe zones    ArcGIS Feature Layer

waste_renderer = map_content.renderer_manager(index=0)

>>> RendererManager(layer=Hazardaous Waste areas)

SubtypeGroupTable

class arcgis.map.group_layer.SubtypeGroupTable(group_layer: SubtypeGroupTable, map: Map | Scene, parent: BaseGroup | Map | Scene)

A SubtypeGroupTable represents a single feature service table that defines multiple subtypes, each of which is exposed in the WebMap as its own logical table with a title and editing/display properties.

Subtype tables (instances of SubtypeTable) are not independent service tables and do not have their own URLs. All subtype tables:

share the same parent table’s URL

belong to the same dataset

use the same REST endpoint

cannot be queried or accessed separately from the parent table

For this reason, the Python API does not expose a .tables property on SubtypeGroupTable. Instead, you can inspect subtype table information using table_info(), which provides a structured summary suitable for display in notebooks.

While subtype tables cannot be manipulated as full tables, you can still manage subtype-specific configuration such as popups and forms using the manager methods inherited from the base group classes.

Key Concept:

A SubtypeGroupTable does not contain multiple standalone tables—it contains multiple subtype definitions stored under one feature service table.

Example

>>> table = m.content.tables[0]
>>> table.table_info
  Layer Index Layer Title Layer Type
0            0        Soil      Table
1            1   Bedrock      Table

This class is intended to be accessed through the tables collection on a Map or GroupLayer. Users should not instantiate it directly.

property table_info: DataFrame: Get a DataFrame with information about the tables in this subtype group table.

SmartMappingManager

class arcgis.map.smart_mapping.SmartMappingManager(source, layer)

A class to manage smart mapping methods. Smart Mapping ONLY works with a rendered map.

Warning

There are a few points to note with these methods: - You need to make sure that the layer has been loaded before calling a method on it. - The map can take a few seconds to reflect the changes from the renderer creation. - Calling any other methods or properties need to be done in a separate cell from this method call due to asynchronous conflicts. - If you do not see the layer update, check the console log for any JavaScript errors.

class_breaks_renderer(break_type: str, field: str | None = None, normalization_field: str | None = None, normalization_type: str | None = None, normalization_total: int | None = None, classification_method: str | None = None, standard_deviation_interval: float | None = None, num_classes: int | None = None, value_expression: str | None = None, value_expression_title: str | None = None, sql_expression: str | None = None, sql_where: str | None = None, outline_optimization_enabled: bool = False, min_value: int | None = None, max_value: int | None = None, default_symbol_enabled: bool = True, for_binning: bool | None = None) → None

ClassBreaksRenderer defines the symbol of each feature in a Layer based on the value of a numeric attribute. Symbols are assigned based on classes or ranges of data. Each feature is assigned a symbol based on the class break in which the value of the attribute falls.

The resulting renderer defines the symbol size of each feature based on the value of the given field value. A default size scheme is determined based on the background of the view. Depending on the classificationMethod, class breaks (or data ranges) are generated based on the statistics of the data. Each feature is assigned a size based on the class break in which the value of the field falls.