arcgis.mapping module

Bases: traitlets.traitlets.HasTraits, collections.OrderedDict

The WebMap class represents a web map and provides access to its basemaps and operational layers as well as functionality to visualize and interact with said basemaps and layers.

An ArcGIS web map is an interactive display of geographic information that you can use to tell stories and answer questions. Maps contain a basemap over which a set of data layers called operational layers are drawn.

Web maps can be used across ArcGIS apps because they adhere to the same web map specification. This provides the functionality to author web maps in one ArcGIS app (including the Python API) and view and modify them in another ArcGIS app.

# USAGE EXAMPLE 1: Creating a WebMap object from an existing web map item

from arcgis.mapping import WebMap
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 = WebMap(wm_item)
type(wm)
>> arcgis.mapping._types.WebMap

# explore the layers in this web map using the 'layers' property
wm.layers
>> [{}...{}]  # returns a list of dictionaries representing each operational layer

# USAGE EXAMPLE 2: Creating a new WebMap object

from arcgis.mapping import WebMap

# create a new WebMap object
wm = WebMap()
type(wm)
>> arcgis.mapping._types.WebMap

# explore the layers in this web map using the 'layers' property
wm.layers
>> []  # returns an empty list. You can add layers using the `add_layer()` method

add_layer(layer, options=None)

Adds the given layer to the WebMap object.

Parameter	Description
layer	Required object. You can add: Layer objects such as FeatureLayer, MapImageLayer, ImageryLayer etc. Item objects, FeatureSet and FeatureCollection Table objects
options	Optional Dict. Specify properties such as title, symbol, opacity, visibility, renderer for the layer that is added. If not specified, appropriate defaults are applied.

Returns

True if layer was successfully added. Else, raises an appropriate exception.

# USAGE EXAMPLE: Add feature layer and map image layer item objects to the WebMap object.

crime_fl_item = gis.content.search("2012 crime")[0]
streets_item = gis.content.search("LA Streets","Map Service")[0]

wm = WebMap()  # create an empty web map with a default basemap
wm.add_layer(streets_item)
>> True

# Add crime layer, but customize the title, transparency and turn off the default visibility.
wm.add_layer(fl_item, {'title':'2012 crime in LA city',
                       'opacity':0.5,
                       'visibility':False})
 >> True

add_table(table, options=None)

Adds the given Table to the WebMap.

Parameter	Description
table	Required object. You can add: Table objects
options	Optional dict. Specify properties such as title, symbol, opacity, visibility, and renderer for the table that is added. If not specified, appropriate defaults are applied.

Returns

True if table was successfully added. Else, raises appropriate exception.

wm = WebMap()
table = Table('https://some-url.com/')
wm.add_table(table)

property basemap

Get/Set the base map layers in the WebMap.

Parameter	Description
value	Required string. What basemap you would like to apply to the map (‘topo’, ‘national-geographic’, etc.). See basemaps and gallery_basemaps for a full list.

Returns

List of basemap layers as dictionaries

# Usage example 1: Get the basemap used in the web map

from arcgis.mapping import WebMap
wm = WebMap(wm_item)

wm.basemap
>> {"baseMapLayers": [
    {"id": "defaultBasemap",
    "layerType": "ArcGISTiledMapServiceLayer",
    "url": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer",
    "visibility": true,
    "opacity": 1,
    "title": "Topographic"
    }],
    "title": "Topographic"
    }

# Usage example 2: Set the basemap used in the web map
from arcgis.mapping import WebMap
wm = WebMap(wm_item)

print(wm.basemaps)
>> ['dark-gray-vector', 'gray-vector', 'hybrid', 'oceans', 'osm', 'satellite', 'streets-navigation-vector', 'streets-night-vector', 'streets-relief-vector', 'streets-vector', 'terrain', 'topo-vector']
wm.basemap = 'dark-gray'
print(wm.gallery_basemaps)
>> ['custom_dark_gray_canvas', 'imagery', 'imagery_hybrid', 'light_gray_canvas', 'custom_basemap_vector_(proxy)', 'world_imagery_(proxy)', 'world_street_map_(proxy)']
wm.basemap = 'custom_dark_gray_canvas'

# Usage example 3: Set the basemap equal to an item
from arcgis.mapping import WebMap
wm = WebMap(wm_item)
# Use basemap from another item as your own
wm.basemap = wm_item_2
wm.basemap = tiled_map_service_item
wm.basemap = image_layer_item
wm.basemap = wm2.basemap
wm.basemap = wm2

Note

If you set a basemap that does not have the same spatial reference as the map, the map’s spatial reference will be updated to reflect this. However, any operational layers will not be re-projected.

property basemap_switcher

Get/Set whether the basemap of the WebMap can be switched.

Parameter	Description
value	Required bool. True to enable, False to disable

Returns

True if Basemap switcher is enabled, False otherwise.

basemap_title(title)

Get/Set the BaseMap Title. Required string title for the basemap that can be used in a table of contents. If None is specified, the current title is returned.

property basemaps

Gets a list of possible base maps to set as the basemap for the WebMap.

property bookmarks

Get/Set whether bookmarks are enabled for the viewer widget.

Parameter	Description
value	Required list of dictionaries. The new bookmarks to be used. This will replace current bookmarks with the ones passed into the list.

Returns

Bookmarks in the WebMap item.

# Usage Example:

from arcgis.mapping import WebMap
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 = WebMap(wm_item)

# get current bookmarks
my_bookmarks = wm.bookmarks

# create new bookmarks to replace others
bookmark1 = {'extent': {'spatialReference': {'latestWkid': 3857, 'wkid': 102100},
            'xmin': -8425179.029160742,
            'ymin': 4189089.021381017,
            'xmax': -8409834.295732513,
            'ymax': 4203784.040068822},
            'name': 'Updated Bookmark 1',
            'thumbnail': {'url': <url for thumbnail>},
            'viewpoint': {'rotation': 30,
            'scale': 7222.3819286,
            'targetGeometry': {'spatialReference': {'latestWkid': 3857, 'wkid': 102100},
            'xmin': -8425179.029160742,
            'ymin': 4189089.021381017,
            'xmax': -8409834.295732513,
            'ymax': 4203784.040068822}}}
bookmark2 = {'extent': {'spatialReference': {'latestWkid': 3857, 'wkid': 102100},
            'xmin': -83200.034567,
            'ymin': 3127089.021381017,
            'xmax': -813434.295732513,
            'ymax': 4203784.040068822},
            'name': 'Updated Bookmark 2',
            'thumbnail': {'url': <url for thumbnail>},
            'viewpoint': {'rotation': 30,
            'scale': 7222.3819286,
            'targetGeometry': {'spatialReference': {'latestWkid': 3857, 'wkid': 102100},
            'xmin': -8425179.029160742,
            'ymin': 4189089.021381017,
            'xmax': -8409834.295732513,
            'ymax': 4203784.040068822}}}

# set new bookmark
wm.bookmarks = [bookmark1, bookmark2]

configure_pop_ups(layer_title, field_names, visibility)

This method can be used to change the visibility of a field for a layer on the Web Map.

Note

Changes will not be seen on the Web Map viewer until the Web Map is saved or updated using the save or update method. Once this is done, reload the Web Map to see changes or view on the Portal Web Map Viewer.

Parameter	Description
layer_title	Required string. The name of the layer.
field_names	Required list of strings. The name of the field to change the visibility of.
visibility	Required bool. True if the field should be visible on the pop up for the layer, else False.

property events

Gets the events associated or attached to the widget.

Returns

A list of events attached to the widget.

property forms

The forms property retrieves the smart forms corresponding to each layer and table in the web map.

Returns

FormCollection

# Usage Example: Updating property of a form.
wm = WebMap()
wm.add_layer(table)
forms = wm.forms
form = forms.get(title="Manhole Inspection")
form.title = "Manhole Inspection Form"
form.update()

property gallery_basemaps

Gets a list of web map titles contained within the Group configured as the organization’s Basemap gallery.

get_layer(item_id=None, title=None, layer_id=None)

The get_layer method retrieves the first layer with a matching itemId, title, or layer_id in the``WebMap`` object’s operational layers.

Note

Pass one of the three parameters into the method to return the layer.

Parameter	Description
item_id	Optional string. Pass the item_id for the operational layer you are trying to reference in the WebMap. Note: Not recommended if using multiple layers from the same original item.
title	Optional string. Pass the title for the operational layer you are trying to reference in the WebMap.
layer_id	Optional string. Pass the id for the operational layer you are trying to reference in the WebMap.

Returns

A FeatureLayer as a dictionary

get_table(item_id=None, title=None, layer_id=None)

The get_table method retrieves the first table with a matching itemId, title, or layer_id in the WebMap object’s tables.

Note

Pass one of the three parameters into the method to return the table.

Parameter	Description
item_id	Optional string. Pass the item_id for the table you are trying to reference in the WebMap.
title	Optional string. Pass the title for the table you are trying to reference in the WebMap.
layer_id	Optional string. Pass the id for the table you are trying to reference in the WebMap.

Returns

A Table object as a dictionary

property height

Get/Set the height of the widget.

Parameter	Description
value	Required float between 0 and 1. (e.g. 0.75)

Returns

A float representing the height of the widget

property layer_visibility

Get/Set whether layer visibility is enabled for the viewer widget.

Parameter	Description
value	Required bool. True to enable, False to disable

Returns

True if layer visibility is enabled for viewer widget, False otherwise.

property layers

Gets the operational layers in the Web Map object.

Returns

List of FeatureLayer as dictionaries

# USAGE EXAMPLE 1: Get the list of layers from a web map

from arcgis.mapping import WebMap
wm = WebMap(wm_item)

wm.layers
>> [{"id": "Landsat8_Views_515",
"layerType": "ArcGISImageServiceLayer",
"url": "https://landsat2.arcgis.com/arcgis/rest/services/Landsat8_Views/ImageServer",
...},
{...}]

len(wm.layers)
>> 2

property legend

Get/Set whether legend visibility is enabled for the viewer widget.

Parameter	Description
value	Required bool. True to enable, False to disable

Returns

True if legend visibility is enabled for viewer widget, False otherwise.

move_from_basemap(layer)

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

Parameter	Definition
layer	Required Dictionary. The layer dictionary that will be sent to operational layers. This dictionary is found when calling the definition property on the WebMap. The layer must already be a part of the baseMapLayers.

Returns

The WebMap definition if successful, else an error.

wm = WebMap(<webmap_item_id>)
layer = wm.definition["baseMap"]["baseMapLayer"][0]
wm.move_from_basemap(layer)
wm.update()

move_to_basemap(layer)

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

Parameter	Definition
layer	Required Dictionary. The layer dictionary that will be sent to basemap layers. This dictionary is found when calling the layers property on the WebMap. The layer must already be in the WebMap.

Returns

The WebMap definition if successful, else an error.

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

property navigation

Get/Set whether navigation is enabled for the viewer widget.

Parameter	Description
value	Required bool. True to enable, False to disable

Returns

True if navigation is enabled for viewer widget, False otherwise.

property offline_areas

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

Note

To create, edit, and manage offline map areas for a web map, you must be the owner of the map and have privileges to create content.

Note

You cannot share a web map that contains an offline map area with a group that allows members to update all items, and organization administrators cannot change ownership of a web map that contains an offline map area.

Returns

The OfflineMapAreaManager for the WebMap object.

property pop_ups

Get/Set whether pop ups are enabled for the viewer widget.

Parameter	Description
value	Required bool. True to enable, False to disable

Returns

True if popups are enabled for viewer widget, False otherwise.

print(file_format, extent, dpi=92, output_dimensions=500, 500, scale=None, rotation=None, spatial_reference=None, layout_template='MAP_ONLY', time_extent=None, layout_options=None)

The print method prints the WebMap 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 WebMap, 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 paramter.
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. To get the list of available templates run get_layout_templates().
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.mapping import WebMap
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 = WebMap(wm_item)

# create an empty web map
wm2 = WebMap()
wm2.add_layer(<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)

remove_layer(layer)

The remove_layer method removes the specified layer from the WebMap.

Note

A user can get the list of layers in map using the layers property and pass one of those layers to this method for removal from the map.

Parameter	Description
layer	Required object. Pass the FeatureLayer that needs to be removed from the map. You can get the list of layers in the map by calling the layers property.

remove_table(table)

The remove_table method removes the specified table from the WebMap.

Note

A user can get the list of tables in map using the tables property and pass one of those tables to this method for removal from the map.

Parameter	Description
table	Required object. Pass the Table that needs to be removed from the map. You can get the list of tables in the map by calling the layers property.

save(item_properties, thumbnail=None, metadata=None, owner=None, folder=None)

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

Note

If you started out with a fresh WebMap object, use this method to save it as a web map Item in your GIS.

Note

If you started with a WebMap 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 WebMap item with your changes, call the update method instead.

Parameter	Description
item_properties	Required 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.
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
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, string, or array. The extent 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).
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.

# USAGE EXAMPLE 1: Save a WebMap object into a new web map item
from arcgis.gis import GIS
from arcgis.mapping import WebMap

# log into your GIS
gis = GIS(url, username, password)

# compose web map by adding, removing, editing layers and basemaps
wm = WebMap()  # new web map
wm.add_layer(...)  # add some layers

# 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')

# to visit the web map using a browser
print(new_wm_item.homepage)
>> 'https://your portal url.com/webadaptor/item.html?id=1234abcd...'

property scale_bar

Get/Set the scale bar type for the viewer widget.

Parameter	Description
value	Required string. Values: ‘none’ (disable) | ‘line’ | ‘ruler’

Returns

A string representing the scale bar type. If “none” then it is disabled.

property search

Get/Set whether search is enabled for the viewer widget.

Parameter	Description
value	Required bool. True to enable, False to disable

Returns

True if search is enabled for viewer widget, False otherwise.

property tables

Gets the tables in the WebMap object.

Returns

List of Table as dictionaries

wm = WebMap()
table = Table('https://some-url.com/')
wm.add_layer(table)
wm.tables
>> [{"id": "fZvgsrA68ElmNajAZl3sOMSPG3iTnL",
     "title": "change_table",
     "url": "https://some-url.com/",
     "popupInfo": {
     ...

update(item_properties=None, thumbnail=None, metadata=None)

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

Note

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

If you started out with a fresh WebMap object (without a web map item), calling this method will raise a RuntimeError exception. If you want to save the WebMap 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).

# USAGE EXAMPLE 1: Update an existing web map

from arcgis.gis import GIS
from arcgis.mapping import WebMap

# log into your GIS
gis = GIS(url, username, password)

# edit web map by adding, removing, editing layers and basemaps
wm = WebMap()  # new web map
wm.add_layer(...)  # add some layers

# 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']}

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

# to visit the web map using a browser
print(new_wm_item.homepage)
>> 'https://your portal url.com/webadaptor/item.html?id=1234abcd...'

update_drawing_info(layer, label_info=None, renderer=None, transparency=None, show_labels=None)

Method to alter a WebMap layer’s drawing info. Works for standalone layers and individual layers found within group layers. Allows for a user to manually add their own renderers and label classes, toggle whether the labels are visible, and control the transparency of a layer. Useful in tandem with the map widget, allowing for style changes without opening the online map viewer.

Note

In order to save changes made through this method, call WebMap.update() or WebMap.save().

Parameter	Description
layer	Required FeatureLayer or Feature Layer dictionary. The existing WebMap layer to be changed. Note In order for this method to work, the layer must be set to have its properties stored in the web map, not the source layer. This is the default setting, and can be confirmed or changed in the online Map Viewer. (Layer properties -> information)
label_info	Optional list of dictionaries. Each dictionary in the list corresponds to a label class. Determines labeling conventions of the passed layer.
renderer	Optional dictonary. Can be manually constructed or the output of generate_renderer(). Determines the layer style of the passed layer.
transparency	Optional int. Determines transparency/opacity of the layer on 0-100 scale, with 0 being fully opaque and 100 being fully transparent.
show_labels	Optional boolean. Determines whether the layer labels are visible or not.

Hint:

Accessing the layers of your Webmap allows you to view the current renderer and label info dictionaries, allowing you to easily copy them and amend the desired details.

Example

# Create Webmap from webmap item, choose a layer to edit
wm = WebMap(<wm_item_id>)
change_layer = wm.layers[0]

# Specify renderer dictionary and labeling info dictionary/dictionaries
rend = {
    "type": "simple",
    "symbol": {
        "type": "esriSLS",
        "color": [200, 50, 0, 250],
        "width": 1,
        "style": "esriSLSSolid"
    }
}

label = [
    {
        "labelExpression": "[llid]",
        "labelExpressionInfo": {"expression": "$feature["llid"]"},
        "labelPlacement": "esriServerLinePlacementCenterAlong",
        "maxScale": 0,
        "minScale": 2311163,
        "repeatLabel": True,
        "symbol": {
            "type": "esriTS",
            "color": [0, 105, 0, 255],
            "font": {"family": "Arial", "size": 9.75},
            "horizontalAlignment": "center",
            "kerning": True,
            "haloColor": [211, 211, 211, 250],
            "haloSize": 1,
            "rotated": False,
            "text": "",
            "verticalAlignment": "baseline",
            "xoffset": 0,
            "yoffset": 0,
            "angle": 0
        }
    }
]

# Call the function. This automatically updates the Webmap info
wm.update_drawing_info(
    change_layer,
    label_info = label,
    renderer = rend,
    transparency = 40,
    show_labels = True,
)

update_layer(layer)

To update the layer dictionary for a layer in the map. For example, to update the renderer dictionary for a layer and have it by dynamically changed on the webmap. Can be used to configure the pop_ups dictionary, renderer, or any other part of the Feature Layer properties.

Parameter	Description
layer	Required FeatureLayer or Feature Layer dictionary. The existing webmap layer with updated properties. In order to get a layer on the webmap, use the layers method and assign the output to a value. Make edits on this value and pass it in as a dict to update the rendering on the map. Warning If the itemId of the feature layer is changed, this will not work.

# Create Webmap from webmap item
wm = WebMap(<wm_item_id>)

# Get a layer and edit the color
fl = wm.layers[0]
fl["layerDefinition"]["drawingInfo"]["renderer"]["symbol"]["color"] = [0, 0, 0, 255]

# Update the layer to see it render on map
wm.update_layer(dict(my_lyr))

# Save with the updates
wm_properties= {"title": "Test Update", "tags":["update_layer"], "snippet":"Updated a layer and now save"}
wm.save(wm_properties)

property view_bookmarks

Get/Set whether bookmarks are enabled for the dashboard widget.

Parameter	Description
value	Required bool. True to enable, False to disable

Returns

True if bookmarks are enabled for viewer widget, False otherwise.

property width

Get/Set the width of the viewer widget.

Parameter	Description
value	Required float between 0 and 1. (e.g. 0.75)

Returns

A float representing the width of the widget

property zoom

Get/Set whether zoom is enabled for the viewer widget.

Parameter	Description
value	Required bool. True to enable, False to disable

Returns

True if zoom is enabled for viewer widget, False otherwise.

Bases: object

The OfflineMapAreaManager is a helper class to manage offline map areas for a Web Map Item. Objects of this class should not be initialized directly, but rather accessed using the offline_areas property on a WebMap object.

>>> from arcgis.gis import GIS
>>> from arcgis.mapping import WebMap

>>> gis = GIS(profile="your_Web_GIS_profile")

>>> wm_item = gis.content.get("<web map id>")
>>> wm_obj = WebMap(wm_item)

>>> oma_mgr = wm_obj.offline_areas
<arcgis.mapping._types.OfflineMapAreaManager at <memory_addr>>

create(area, item_properties=None, folder=None, min_scale=None, max_scale=None, layers_to_ignore=None, refresh_schedule='Never', refresh_rates=None, enable_updates=False, ignore_layers=None, tile_services=None, future=False)

This method creates offline map area items and packages for ArcGIS Runtime powered applications to use. The method creates two different types of Items

• Map Area items for the specified extent, bookmark, or polygon

• Map Area Packages corresponding to the operational layer(s) and basemap layer(s) within the extent, bookmark or polygon area

Note

Packaging will fail if the size of the offline map area, when packaged, is larger than 2.5 GB.

• If packaging fails, try using a smaller bookmark, extent or geometry for the area argument.

• If the map contains feature layers that have attachments, you can exclude attachments from the offline package to decrease the package size.

• If the map includes tile layers, use the tile_services argument to constrain the number of levels included in the resulting packages. This is typically required to reduce the tile package size for the basemap layer(s) in ArcGIS Enterprise.

Note

Only the owner of the Web Map item can create offline map areas.

Parameter	Description
area	Required bookmark, extent, or Polygon object. Specify as either: bookmark name >>> wm_item = gis.content.get("<web map id>") >>> wm_obj = WebMap(wm_item) >>> wm_bookmarks = wm_obj.bookmarks >>> area = wm_bookmarks[0] extent: as a list of coordinate pairs: >>> area = [['xmin', 'ymin'], ['xmax', 'ymax']] extent: as a dictionary: >>> area = { 'xmin': <value>, 'ymin': <value>, 'xmax': <value>, 'ymax': <value>, 'spatialReference' : {'wkid' : <value>} } polygon: as a Polygon object Note If spatial reference is not specified, it is assumed {‘wkid’: 4326}.
item_properties	Required dictionary. See table below for the keys and values.
folder	Optional string. Specify a folder name if you want the offline map area item and the packages to be created inside a folder. Note These items will not display when viewing the content folder in a web browser. They will display in the Portal tab of the Content Pane in ArcGIS Pro.
min_scale	Optional integer. Specify the minimum scale to cache tile and vector tile layers. When zoomed out beyond this scale, cached layers would not display. Note The min_scale value is always larger than the max_scale.
max_scale	Optional integer. Specify the maximum scale to cache tile and vector tile layers. When zoomed in beyond this scale, cached layers would not display.
layers_to_ignore	Optional List of layer objects to exclude when creating offline packages. You can get the list of layers in a web map by calling the layers property on the WebMap object.
refresh_schedule	Optional string. Allows for the scheduling of refreshes at given times. The following are valid variables: Never - never refreshes the offline package (default) Daily - refreshes everyday Weekly - refreshes once a week Monthly - refreshes once a month
refresh_rates	Optional dict. This parameter allows for the customization of the scheduler. The dictionary accepts the following: { "hour" : 1 "minute" = 0 "nthday" = 3 "day_of_week" = 0 } hour - a value between 0-23 (integers) minute - a value between 0-60 (integers) nthday - this is used for monthly only. Thw refresh will occur on the ‘n’ day of the month. day_of_week - a value between 0-6 where 0 is Sunday and 6 is Saturday. # Example **Daily**: every day at 10:30 AM UTC >>> refresh_rates = { "hour": 10, "minute" : 30 } # Example **Weekly**: every Wednesday at 11:59 PM UTC >>> refresh_rates = { "hour" : 23, "minute" : 59, "day_of_week" : 4 }
enable_updates	Optional Boolean. Allows for the updating of the layers.
ignore_layers	Optional List. A list of individual layers, specified with their service URLs, in the map to ignore. The task generates packages for all map layers by default. >>> ignore_layers = [ "https://services.arcgis.com/ERmEceOGq5cHrItq/arcgis/rest/services/SaveTheBaySync/FeatureServer/1", "https://services.arcgis.com/ERmEceOGq5cHrItq/arcgis/rest/services/WildfireSync/FeatureServer/0" ]
tile_services	Optional List. An list of Python dictionary objects that contains information about the export tiles-enabled services for which tile packages (.tpk or .vtpk) need to be created. Each tile service is specified with its url and desired level of details. >>> tile_services = [ { "url": "https://tiledbasemaps.arcgis.com/arcgis/rest/services/World_Imagery/MapServer", "levels": "17,18,19" } Note This argument should be specified when using ArcGIS Enterprise items. The number of levels included greatly impacts the overall size of the resulting packages to keep them under the 2.5 GB limit.
future	Optional boolean. If True, a future object will be returned and the process will return control to the user before the task completes. If False, control returns once the operation completes. The default is False.

Key:Value Dictionary options for argument item_properties

Key	Value
description	Optional string. Description of the item.
title	Optional string. Name label of the item.
tags	Optional string of comma-separated values, or a list of strings for each tag.
snippet	Optional string. Provide a short summary (limit to max 250 characters) of the what the item is.

Returns

Map Area Item, or if future=True, a PackagingJob object to further query for results.

# USAGE EXAMPLE #1: Creating offline map areas using *scale* argument

>>> from arcgis.gis import GIS
>>> from arcgis.mapping import WebMap

>>> gis = GIS(profile="your_online_organization_profile")

>>> wm_item = gis.content.get("<web_map_id>")
>>> wm_obj = WebMap(wm_item)

>>> item_prop = {"title": "Clear lake hyperspectral field campaign",
                 "snippet": "Offline package for field data collection using spectro-radiometer",
                 "tags": ["python api", "in-situ data", "field data collection"]}

>>> aviris_layer = wm_item.layers[-1]

>>> north_bed = wm_obj.bookmarks[-1]['name']
>>> wm.offline_areas.create(area=north_bed,
                            item_properties=item_prop,
                            folder="clear_lake",
                            min_scale=9000,
                            max_scale=4500,
                            layers_to_ignore=[aviris_layer])

# USAGE Example #2: ArcGIS Enterprise web map specifying *tile_services*

>>> gis = GIS(profile="your_enterprise_profile")

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

# Enterprise: Get the url for tile services from basemap
>>> basemap_lyrs = wm_obj.definition["baseMap"]["baseMapLayers"]
>>> basemap_lyrs

    [
     {'id': '18d9e5e151c-layer-2',
      'title': 'Light_Gray_Export_AGOL_Group',
      'itemId': '042f5e5aadcb8dbd910ae310b1f26d18',
      'layerType': 'VectorTileLayer',
      'styleUrl': 'https:/example.com/portal/sharing/servers/042f5e5aadcb8dbd910ae310b1f26d1/rest/services/World_Basemap_Export_v2/VectorTileServer/resources/styles/root.json'}
    ]

# Get the specific Tile Layer item to see options for levels
>>> vtl_item = gis.content.get(basemap_lyrs[0]["itemId"])
>>> vtl_lyr = vtl_item.layers[0]
>>> print(f"min levels: {vtl_lyr.properties['minLOD']}")
>>> print(f"max levels: {vtl_lyr.properties['maxLOD']}")

    min levels: 0
    max levels: 16

>>> vtl_svc_url = vtl_item.layers[0].url
>>> vtl_svc_url
https:/example.com/portal/sharing/servers/042f5e5aadcb8dbd910ae310b1f26d1/rest/services/World_Basemap_Export_v2/VectorTileServer

# Get a list of bookmark names to iterate through
>>> bookmarks = wm_obj.bookmarks
>>> bkmrk_names = [bookmark["name"] for bookmark in bookmarks]
>>> bname = bkmrk_names[1]

>>> oma = offline_mgr.create(area=bname,
                             item_properties={"title": bname + "_OMA",
                                              "tags": "offline_mapping,administrative boundaries,parks",
                                              "snippet": bname + " in County",
                                              "description": "Offline mapping area in " + bname + " for sync"},
                             tile_services=[{"url": vtl_svc_url,
                                             "levels": "6,7,8,9,10,11,12,13"}])
>>> oma
<Item title:"County_OMA" type:Map Area owner:gis_user>

>>> # List packages created:
>>> for oma_pkg in oma.related_items("Area2Package", "forward"):
>>>     print(f"{oma_pkg.title:60}{oma_pkg.type}")

<County_Layer-<id_string>                SQLite Geodatabase
<VectorTileServe-<id_string>             Vector Tile Package

Note

This method executes silently. To view informative status messages, set the verbosity environment variable as shown below prior to running the method:

# USAGE EXAMPLE: setting verbosity

>>> from arcgis import env
>>> env.verbose = True

list()

Retrieves a list of all Map Area items for the WebMap object.

Note

Map Area items and the corresponding offline packages share a relationship of type Area2Package. You can use this relationship to get the list of package items cached for each map area item. Refer to the Python snippet below for the steps:

# USAGE EXAMPLE: Listing Map Area Items

>>> from arcgis.gis import GIS
>>> from arcgis.mapping import WebMap

>>> wm_item = gis.content.search("*", "Web Map")[0]
>>> wm_obj = WebMap(wm_item)

>>> all_map_areas = wm.offline_areas.list()
>>> all_map_areas

[<Item title:"Ballerup_OMA", type:Map Area owner:gis_user1>,
 <Item title:"Viborg_OMA", type:Map Area owner:gis_user1>]

# USAGE Example: Inspecting Map Area packages

>>> area1 = all_map_areas[0]
>>> area1_packages = area1.related_items("Area2Package","forward")

>>> for pkg in area1_packages:
>>>     print(f"{pkg.title}")
<<<     print(f"{' ' * 2}{pkg.type}")
>>>     print(f"{' ' * 2}{pkg.homepage}")

VectorTileServe-<value_string>
  Vector Tile Package
  https://<organziation_url>/home/item.html?id=<item_id>


DK_lau_data-<value_string>
  SQLite Geodatabase
  https://organization_url/home/item.html?id=<item_id>

Returns

A List of Map Area :class`items <arcgis.gis.Item>` related to the Web Map item.

modify_refresh_schedule(item, refresh_schedule=None, refresh_rates=None)

The modify_refresh_schedule method modifies an existing offline package’s refresh schedule.

Parameter	Description
item	Required Item object. This is the Offline Package to update the refresh schedule.
refresh_schedule	Optional String. This is the rate of refreshing. The following are valid variables: Never - never refreshes the offline package (default) Daily - refreshes everyday Weekly - refreshes once a week Monthly - refreshes once a month
refresh_rates	Optional dict. This parameter allows for the customization of the scheduler. Note all time is in UTC. The dictionary accepts the following: { “hour” : 1 “minute” = 0 “nthday” = 3 “day_of_week” = 0 } hour - a value between 0-23 (integers) minute a value between 0-60 (integers) nthday - this is used for monthly only. This say the refresh will occur on the ‘x’ day of the month. day_of_week - a value between 0-6 where 0 is Sunday and 6 is Saturday. Example Daily: { “hour”: 10, “minute” : 30 } This means every day at 10:30 AM UTC Example Weekly: { “hour” : 23, “minute” : 59, “day_of_week” : 4 } This means every Wednesday at 11:59 PM UTC

Returns

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

## Updates Offline Package Building Everyday at 10:30 AM UTC

gis = GIS(profile='owner_profile')
item = gis.content.get('9b93887c640a4c278765982aa2ec999c')
oa = wm.offline_areas.modify_refresh_schedule(item.id, 'daily', {'hour' : 10, 'minute' : 30})

property offline_properties

This property allows users to configure the offline properties for a webmap. The offline_properties allows for defining how available offline editing, basemap, and read-only layers behave in the web map application. For further reading about concepts for working with web maps offline, see Configure the map to work offline. Also, see the applicationProperties object in the Web Map specification.

Parameter	Description
values	Required Dict. The key/value pairs that define the offline application properties.

The dictionary supports the following keys:

Key	Values
download	Optional string. Possible values: None features features_and_attachments When editing layers, the edits are always sent to the server. This string argument indicates which data is retrieved from the server. If argument is None - only the schema is written since neither features nor attachments are retrieved If argument is features - a full sync without downloading attachments occurs If argument is features_and_attachments, which is the Default - both features and attachments are retrieved
sync	sync applies to editing layers only. This string value indicates how the data is synced: sync_features_and_attachments - bidirectional sync sync_features_upload_attachments - bidirectional sync for features but upload only for attachments upload_features_and_attachments - upload only for both features and attachments (initial replica is just a schema)
reference_basemap	The filename of a basemap that has been copied to a mobile device. This can be used instead of the default basemap for the map to reduce downloads.
get_attachments	Boolean value that indicates whether to include attachments with the read-only data.

Returns

Dictionary

# USAGE EXAMPLE

>>> from arcgis.gis import GIS
>>> from arcgis.mapping import WebMap

>>> wm_item = gis.content.get("<web_map_id>")
>>> wm_obj = WebMap(wm_item)

>>> offline_mgr = wm_obj.offline_areas
>>> offline_mgr.offline_properties = {"download": "features",
                                      "sync": "sync_features_upload_attachments"}

update(offline_map_area_items=None, future=False)

The update method refreshes existing map area packages associated with each of the Map Area items specified. This process updates the packages with changes made on the source data since the last time those packages were created or refreshed. See Refresh Map Area Package for more information.

Parameter	Description
offline_map_area_items	Optional list. Specify one or more Map Area items for which the packages need to be refreshed. If not specified, this method updates all the packages associated with all the map area items of the web map. Note To get the list of Map Area items related to the WebMap object, call the list() method on the OfflineMapAreaManager for the WebMap.
future	Optional Boolean.

Returns

Dictionary containing update status.

Note

This method executes silently. To view informative status messages, set the verbosity environment variable as shown below before running the code:

USAGE EXAMPLE: setting verbosity

from arcgis import env
env.verbose = True

Bases: object

The PackagingJob class represents a Single Packaging Job.

cancel()

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()

The cancelled method retrieves whether the call was successfully cancelled.

Returns

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

done()

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

Returns

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

property ellapse_time

The ellapse_time property retrieves the Ellapse Time for the Job.

Returns

The elapsed time

result()

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()

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

Get the GP status of the call.

Returns

A String

Bases: collections.OrderedDict

The WebScene represents a web scene and provides access to its basemaps and operational layers as well as functionality to visualize and interact with them.

If you would like more robust webscene authoring functionality, consider using the MapView class. You need to be using a Jupyter environment for the MapView class to function properly, but you can make copies of WebScenes, add layers using a simple add_layer() call, adjust the basemaps, save to new webscenes, and more.

update([E, ]**F) → None. Update D from dict/iterable E and F.

If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

Bases: arcgis.gis.Layer

The SceneLayer class represents a Web scene layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

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

type(s_layer)
>> arcgis.mapping._types.PointCloudLayer

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

Bases: arcgis.gis._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)

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)

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)

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)

Returns the job statistics for the given jobId

jobs()

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)

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()

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

rerun_job(job_id, code)

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)

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()

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)

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 seperated values indicating the id of the layers to update in the cache. Ex: [0,1,2]

update_cache(layers)

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 seperated values indicating the id of the layers to update in the cache. Ex: [0,1,2]

Bases: arcgis.gis._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)

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_dictionairy)

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.

Parameter	Description
service_dictionairy	Required dict. The service JSON as a dictionary.

Returns

boolean

rebuild_cache(layer=None, extent=None, area_of_interest=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 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=None, extent=None, area_of_interest=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 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=None, extent=None, area_of_interest=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 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: arcgis.gis.Layer

The BuildingLayer class represents a Web building layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

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

type(s_layer)
>> arcgis.mapping._types.BuildingLayer

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

property manager

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

Bases: arcgis.gis.Layer

The IntegratedMeshLayer class represents a Web scene Integrated Mesh layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

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

type(s_layer)
>> arcgis.mapping._types.Point3DLayer

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

property manager

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

Bases: arcgis.gis.Layer

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

property manager

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

Bases: arcgis.gis.Layer

The Object3DLayer represents a Web scene 3D Object layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

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

type(s_layer)
>> arcgis.mapping._types.Point3DLayer

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

property manager

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

Bases: arcgis.gis.Layer

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

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

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

type(s_layer)
>> arcgis.mapping._types.Point3DLayer

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

property manager

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

Bases: arcgis.gis.Layer

The PointCloudLayer class represents a Web scene Point Cloud layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

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

type(s_layer)
>> arcgis.mapping._types.PointCloudLayer

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

property manager

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

Bases: arcgis.gis.Layer

The VoxelLayer class represents a Web Scene Voxel layer.

# USAGE EXAMPLE 1: Instantiating a SceneLayer object

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

type(s_layer)
>> arcgis.mapping._types.VoxelLayer

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

property manager

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

Bases: arcgis.gis.Layer

The MapServiceLayer class is a factory that generates the Map Service Layers.

# USAGE EXAMPLE 1: Instantiating a Map Service Layer object

from arcgis.mapping import MapServiceLayer
ms_layer = MapServiceLayer(url='https://your_portal.com/arcgis/rest/services/service_name/MapServer/0')

type(ms_layer)
>> arcgis.mapping._types.MapTable

print(ms_layer.properties.name)
>> 'pipe_properties'

Bases: arcgis.gis.Layer

The MapFeatureLayer class represents Map Feature Layers. Map Feature Layers can be added to and visualized using maps.

Map Feature Layers are created by publishing feature data to a GIS, and are exposed as a broader resource (Item) in the GIS. MapFeatureLayer objects can be obtained through the layers attribute on map image service Items in the GIS.

property attachements

The attachements property provides a manager to work with attachments if the MapFeatureLayer supports this functionality.

property container

The container property represents the MapImageLayer to which this layer belongs.

export_attachments(output_folder, label_field=None)

The export_attachments method exports attachments from the map feature layer in Imagenet format using the output_label_field.

Parameter	Description
output_folder	Required String. Output folder path where the attachments will be stored.
label_field	Optional. Field which contains the label/category of each feature. If None, a default folder is created.

Returns

A path to the exported attachments

classmethod fromitem(item, layer_id=0)

The fromitem method creates a MapFeatureLayer from a GIS Item.

Parameter	Description
item	Required Item object. The type of item should be a MapServiceLayer object.
layer_id	Optional integer. The id of the layer in the Map Service’s Layer. The default is 0.

Returns

A MapFeatureLayer object

# USAGE EXAMPLE

>>> from arcgis.mapping 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)
>>> print(f"{map_feature_layer.properties.name:30}{type(map_feature_layer)}")
<State Boundaries              <class 'arcgis.mapping._msl.layer.MapFeatureLayer'>>

generate_renderer(definition, where=None)

The generate_renderer operation groups data using the supplied definition (classification definition) and an optional where clause. The result is a renderer object. Use baseSymbol and colorRamp to define the symbols assigned to each class.

Note

If the operation is performed on a table, the result is a renderer object containing the data classes and no symbols.

Parameter	Description
definition	Required dict. The definition using the renderer that is generated. Use either class breaks or unique value classification definitions. See the classification definitions page in the ArcGIS REST API documentation for more information.
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

dictionary

get_html_popup(oid)

The get_html_popup resource provides details about the HTML pop-up authored by the user using ArcGIS Pro or ArcGIS Desktop.

Parameter	Description
oid	Optional string. Object id of the feature to get the HTML popup.

Returns

A string

get_unique_values(attribute, query_string='1=1')

The get_unique_values method retrieves a list of unique values for a given attribute.

Parameter	Description
attribute	Required string. The map feature layer attribute to query.
query_string	Optional string. SQL Query that will be used to filter attributes before unique values are returned.

Returns

A List

# USAGE EXAMPLE

>>> from arcgis.mapping 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)
>>> unique_values = map_feature_layer.get_unique_values(attribute ="Name",
                                        query_string ="name_2 like '%K%'")
>>> type(unique_values)
<List>

query(where='1=1', text=None, out_fields='*', time_filter=None, geometry_filter=None, return_geometry=True, return_count_only=False, return_ids_only=False, return_distinct_values=False, return_extent_only=False, group_by_fields_for_statistics=None, statistic_filter=None, result_offset=None, result_record_count=None, object_ids=None, distance=None, units=None, max_allowable_offset=None, out_sr=None, geometry_precision=None, gdb_version=None, order_by_fields=None, out_statistics=None, return_z=False, return_m=False, multipatch_option=None, quantization_parameters=None, return_centroid=False, return_all_records=True, result_type=None, historic_moment=None, sql_format=None, return_true_curves=False, return_exceeded_limit_features=None, as_df=False, datum_transformation=None, range_values=None, parameter_values=None, **kwargs)

The query method queries a map feature layer based on a sql statement.

Parameter	Description
where	Optional string. The default is 1=1. The selection sql statement.
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 either as a List of field names or as 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 of startTime and endTime values. :Syntax: >>> time_filter=[<startTime>, <endTime>] Note Specified as datetime.date, datetime.datetime or timestamp in milliseconds
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 returns_ids_only parameter. If returnCountOnly = True , the response will return both the count and the extent.
return_extent_only	Optional boolean. If True, the response only includes the extent of the features satisying 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. 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_statiscits = "STATE_NAME, GENDER"
out_statistics	Optional List. The definitions for one or more field-based statistics to be calculated. Syntax >>> out_statistics = [ { "statisticType": "<count | sum | min | max | avg | stddev | var>", "onStatisticField": "Field1", "outStatisticFieldName": "Out_Field_Name1" }, { "statisticType": "<count | sum | min | max | avg | stddev | var>", "onStatisticField": "Field2", "outStatisticFieldName": "Out_Field_Name2" } ]
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).
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).
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" : "<id>", "forward" : True | False}, {"wkt" : "WKT", "forward" : True: 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": "range name" , # single value or a value-range "value": <value> or [ <value1>, <value2> ] }, { "name": "range name 2", "value": <value> or [ <value3>, <value4> ] } ] Note None is allowed in value-range case to indicate infinity # all features with values <= 1500 >>> range_values = [ {"name" : "range name", "value" : [None, 1500]} ] # all features with values >= 1000 >>> range_values = [ {"name" : "range name", "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 dict. Optional parameters that can be passed to the Query function. This will allow users to pass additional parameters not explicitly implemented on the function. A complete list of functions available is documented at Query (Feature Service/Layer).

Returns

A FeatureSet containing the features matching the query unless another

return type is specified, such as count.

# USAGE EXAMPLE

>>> from arcgis.mapping 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 "1=1",
                            text = "Hurricane Data",
                            units = "esriSRUnit_Meter",
                            return_count_only = True,
                            out_statistics = [
                                                {
                                                "statisticType": "count",
                                                "onStatisticField": "Field1",
                                                "outStatisticFieldName": "Out_Field_Name1"
                                                },
                                                {
                                                "statisticType": "avg",
                                                "onStatisticField": "Field2",
                                                "outStatisticFieldName": "Out_Field_Name2"
                                                }
                                            ],
                            range_values= [
                                    {
                                      "name": "range name",
                                      "value": [None, 1500]
                                      },
                                      {
                                        "name": "range name 2",
                                        "value":[1000, None]
                                      }
                                    }
                                ]
                            )
>>> query_count
<149>

query_related_records(object_ids, relationship_id, out_fields='*', definition_expression=None, return_geometry=True, max_allowable_offset=None, geometry_precision=None, out_wkid=None, gdb_version=None, return_z=False, return_m=False, historic_moment=None, return_true_curve=False)

The query_related_records operation is performed on a MapFeatureLayer resource. The result of this operation are FeatureSet objects 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 the query method for more information.

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	Required string. the list of 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/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_curves	Optional boolean. Optional parameter that is false by default. When set to true, returns true curves in output geometries; otherwise, curves are converted to densified polylines or polygons.

Returns

dict

property renderer

Get/Set the Renderer of the Map Feature Layer.

Note

The renderer property overrides the default symbology when displaying it on a WebMap.

Returns

InsensitiveDict: A case-insensitive dict like object used to update and alter JSON A varients of a case-less dictionary that allows for dot and bracket notation.

property time_filter

Starting at Enterprise 10.7.1+, instead of querying time-enabled map service layers or time-enabled feature service layers, a time filter can be set using the time_filter property. Time can be filtered as Python datetime, objects or strings representing Unix epoch values in milliseconds. An extent can be specified by separating the start and stop values comma.

>>> import datetime as dt

>>> map_feature_lyr.time_filter = [dt.datetime(2021, 1, 1), dt.datetime(2022, 1, 10)]

Bases: arcgis.mapping._msl.layer.MapFeatureLayer

The MapRasterLayer class represents a geo-referenced image hosted in a Map Service.

Bases: arcgis.gis.Layer

The MapImageLayer allows you to display and analyze data from sublayers defined in a map service, exporting images instead of features. Map service images are dynamically generated on the server based on a request, which includes an LOD (level of detail), a bounding box, dpi, spatial reference and other options. The exported image is of the entire map extent specified.

create_dynamic_layer(layer)

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.mapping 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>